movemanager.cpp

墨香最新私服

}

void CMoveManager::MoveStop(CObject* pObject,VECTOR3* pStopPos)
{
	if(pObject->m_MoveInfo.bMoving)
		EndMove(pObject);
	if(pStopPos)
	{
		pObject->m_MoveInfo.CurPosition = *pStopPos;
		pObject->SetPosition(pStopPos);
	}
	else
	{
		pObject->SetPosition(&pObject->m_MoveInfo.CurPosition);
	}
}

void CMoveManager::HeroMoveStop()
{
	CHero* pHero = OBJECTMGR->GetHero();
	if(pHero->m_MoveInfo.bMoving == FALSE)
		return;
	
	CalcPositionEx(pHero,gCurTime);
	
	MoveStop(pHero,&pHero->m_MoveInfo.CurPosition);
	// 惑怕 函版
	if(pHero->GetState() == eObjectState_Die)
		return;

	if( !OBJECTSTATEMGR->StartObjectState(pHero, eObjectState_None) )
		return;	

	MOVE_POS msg;
	msg.Category = MP_MOVE;
	msg.Protocol = MP_MOVE_STOP;
	msg.dwObjectID = HEROID;
	msg.dwMoverID = HEROID;
	msg.cpos.Compress(&pHero->m_MoveInfo.CurPosition);

	NETWORK->Send(&msg,sizeof(MOVE_POS));
}

float CMoveManager::CalcDistance(CObject* pObject1,CObject* pObject2)
{
	float tx = pObject1->m_MoveInfo.CurPosition.x - pObject2->m_MoveInfo.CurPosition.x;
	float tz = pObject1->m_MoveInfo.CurPosition.z - pObject2->m_MoveInfo.CurPosition.z;

	return sqrtf(tx*tx+tz*tz);
}


void CMoveManager::SetWalkMode(CObject* pObject)
{
	pObject->m_MoveInfo.MoveMode = eMoveMode_Walk;
	
	if(pObject->GetObjectKind() == eObjectKind_Player)
	{
		((CPlayer*)pObject)->SetBaseMotion();
	}
}
void CMoveManager::SetRunMode(CObject* pObject)
{
	pObject->m_MoveInfo.MoveMode = eMoveMode_Run;
	
	if(pObject->GetObjectKind() == eObjectKind_Player)
	{
		((CPlayer*)pObject)->SetBaseMotion();
	}
}

BOOL CMoveManager::SetKyungGong(CObject* pObject,WORD KGIdx)
{
	if(IsValidKyungGong(pObject,KGIdx) == FALSE)
		return FALSE;

	pObject->m_MoveInfo.KyungGongIdx = KGIdx;

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


	return TRUE;
}
BOOL CMoveManager::SetMonsterMoveType(CObject* pObject,WORD KGIdx)
{
	if(!pObject) return FALSE;
	if((pObject->GetObjectKind() & eObjectKind_Monster) == FALSE)
	{
		ASSERT(0);
		return FALSE;
	}
	
	pObject->m_MoveInfo.KyungGongIdx = KGIdx;
	return TRUE;
}

BOOL CMoveManager::IsValidKyungGong(CObject* pObject,WORD KGIdx)
{
	return TRUE;
}

float CMoveManager::GetKyungGongSpeed(WORD KyungGongIdx)
{
	ASSERT(KyungGongIdx);
	CKyungGongInfo* pKGInfo = KYUNGGONGMGR->GetKyungGongInfo(KyungGongIdx);
	ASSERT(pKGInfo);
	if(pKGInfo == NULL)
		return 0;

	return pKGInfo->GetSpeed();
}

void CMoveManager::EffectYMove(CObject* pObject,float StartY,float EndY,DWORD Duration)
{
	MOVE_INFO* pMoveInfo = &pObject->m_MoveInfo;

	pMoveInfo->bMoving = TRUE;
	pObject->m_bIsYMoving = TRUE;

	float Speed;	
	
	pMoveInfo->Move_StartTime = gCurTime;

	VECTOR3 CurPos;
	pObject->GetPosition(&CurPos);

	pMoveInfo->Move_StartPosition.x = CurPos.x;
	pMoveInfo->Move_StartPosition.z = CurPos.z;
	pMoveInfo->Move_StartPosition.y = CurPos.y + StartY;

	ASSERT( pMoveInfo->GetCurTargetPosIdx() <= MAX_CHARTARGETPOSBUF_SIZE );	//0000
	pMoveInfo->GetTargetPosition(pMoveInfo->GetCurTargetPosIdx())->x = CurPos.x;
	pMoveInfo->GetTargetPosition(pMoveInfo->GetCurTargetPosIdx())->z = CurPos.z;
	pMoveInfo->GetTargetPosition(pMoveInfo->GetCurTargetPosIdx())->y = CurPos.y + EndY;
	//taiyoe
	/*
	pMoveInfo->TargetPosition.x = CurPos.x;
	pMoveInfo->TargetPosition.z = CurPos.z;
	pMoveInfo->TargetPosition.y = CurPos.y + EndY;
	*/

	float Distance = EndY - StartY;
	if(Duration == 0)
		Duration = 1;
	float fTime = Duration * 0.001f;
	Speed = Distance / fTime;
	pMoveInfo->Move_Direction.x = 0;
	pMoveInfo->Move_Direction.y = Speed;
	pMoveInfo->Move_Direction.z = 0;
	pMoveInfo->Move_EstimateMoveTime = fTime;
	
	pObject->GetEngineObject()->ApplyHeightField(FALSE);
}

void CMoveManager::EffectMove(CObject* pObject,VECTOR3* TargetPos,DWORD Duration)
{
	MOVE_INFO* pMoveInfo = &pObject->m_MoveInfo;
	if(pObject->m_bIsYMoving)
	{
		EndYMove(pObject);
	}

	VECTOR3 repos;
	if( MAP->CollisonCheck(&pMoveInfo->CurPosition,TargetPos,&repos,pObject) == TRUE )
		*TargetPos = repos;



	pMoveInfo->bMoving = TRUE;
	pMoveInfo->m_bEffectMoving = TRUE;

	float Speed;	
	
	pMoveInfo->Move_StartTime = gCurTime;

	pMoveInfo->SetCurTargetPosIdx(0);
	pMoveInfo->SetMaxTargetPosIdx(1);

	pMoveInfo->Move_StartPosition.x = pMoveInfo->CurPosition.x;
	pMoveInfo->Move_StartPosition.z = pMoveInfo->CurPosition.z;
	pMoveInfo->Move_StartPosition.y = 0;

	ASSERT( pMoveInfo->GetCurTargetPosIdx() <= MAX_CHARTARGETPOSBUF_SIZE );	//0000
	pMoveInfo->GetTargetPosition(pMoveInfo->GetCurTargetPosIdx())->x = TargetPos->x;
	pMoveInfo->GetTargetPosition(pMoveInfo->GetCurTargetPosIdx())->z = TargetPos->z;
	pMoveInfo->GetTargetPosition(pMoveInfo->GetCurTargetPosIdx())->y = 0;
/*
	pMoveInfo->TargetPosition.x = TargetPos->x;
	pMoveInfo->TargetPosition.z = TargetPos->z;
	pMoveInfo->TargetPosition.y = 0;
*/
	

	float dx = pMoveInfo->GetTargetPosition(pMoveInfo->GetCurTargetPosIdx())->x - pMoveInfo->Move_StartPosition.x;
	float dz = pMoveInfo->GetTargetPosition(pMoveInfo->GetCurTargetPosIdx())->z - pMoveInfo->Move_StartPosition.z;
	float Distance = sqrtf(dx*dx+dz*dz);
	if(Distance <= 0.01)
	{
		EndMove(pObject);
		return;
	}
	if(Duration == 0)
		Duration = 1;
	float fTime = Duration * 0.001f;
	Speed = Distance / fTime;
	float ttt = Speed / Distance;
	pMoveInfo->Move_Direction.x = dx*ttt;
	pMoveInfo->Move_Direction.y = 0;
	pMoveInfo->Move_Direction.z = dz*ttt;
	pMoveInfo->Move_EstimateMoveTime = fTime;
}

void CMoveManager::HeroEffectMove(CObject* pObject,VECTOR3* TargetPos,DWORD Duration,CObject* pOperator)
{
	if( pObject->GetObjectKind() == eObjectKind_SkillObject ||
		pObject->GetObjectKind() == eObjectKind_Tactic ||
		pObject->GetObjectKind() == eObjectKind_Item )
		return;

	if(pObject != HERO && pOperator != HERO)
	{
		EffectMove(pObject,TargetPos,Duration);
		return;
	}

	if(pObject == HERO)
	{
		HeroMoveStop();
	}
	
	pObject->m_MoveInfo.SetCurTargetPosIdx(0);
	pObject->m_MoveInfo.SetMaxTargetPosIdx(1);
	EffectMove(pObject,TargetPos,Duration);

	if(pObject->IsDied() == FALSE)
	{
		MOVE_POS msg;
		msg.Category = MP_MOVE;
		msg.Protocol = MP_MOVE_EFFECTMOVE;
		msg.dwObjectID = HEROID;
		msg.dwMoverID = pObject->GetID();
		msg.cpos.Compress(TargetPos);
		NETWORK->Send(&msg,sizeof(msg));	
	}
}

void CMoveManager::EffectMoveInterpolation(CObject* pObject,VECTOR3* TargetPos)
{
	if(pObject->IsDied())
		return;

	
	MOVE_INFO* pMoveInfo = &pObject->m_MoveInfo;
	DWORD dwTime = (DWORD)(pMoveInfo->Move_EstimateMoveTime * 1000);
	DWORD ElapsedTime = gCurTime - pMoveInfo->Move_StartTime;
	if(ElapsedTime >= dwTime)
	{
		if(pObject->m_MoveInfo.bMoving == FALSE)
			SetPosition(pObject,TargetPos);
	}
	else
	{
		DWORD RemainTime = dwTime - ElapsedTime;
		EffectMove(pObject,TargetPos,RemainTime);
	}
	
}

void CMoveManager::ToggleHeroMoveMode()
{
	VECTOR3 TargetPos;
	BOOL bTarget = FALSE;
	if(IsMoving(HERO))
	{
		bTarget = TRUE;
		TargetPos = *HERO->m_MoveInfo.GetTargetPosition(HERO->m_MoveInfo.GetCurTargetPosIdx());
	}

	HeroMoveStop();
	
	MSGBASE msg;
	msg.Category = MP_MOVE;
	msg.dwObjectID = HEROID;
	if(HERO->m_MoveInfo.MoveMode == eMoveMode_Walk)
	{
		msg.Protocol = MP_MOVE_RUNMODE;
//KES CHARSTATEDLG 031016
		if(GAMEIN->GetCharStateDialog())
			GAMEIN->GetCharStateDialog()->SetMoveMode( FALSE );
//
	}
	else
	{
		msg.Protocol = MP_MOVE_WALKMODE;
//KES CHARSTATEDLG 031016
		if(GAMEIN->GetCharStateDialog())
			GAMEIN->GetCharStateDialog()->SetMoveMode( TRUE );
//
	}
	NETWORK->Send(&msg,sizeof(msg));

	if(HERO->m_MoveInfo.MoveMode == eMoveMode_Walk)
		SetRunMode(HERO);
	else
		SetWalkMode(HERO);

	if(bTarget)
	{
		SetHeroTarget(&TargetPos,FALSE);
	}
}

void CMoveManager::ToggleHeroKyungGongMode()
{
	WORD kgidx = HERO->m_MoveInfo.KyungGongIdx;
	MSG_DWORD2 msg;
	msg.Category = MP_MOVE;
	msg.Protocol = MP_MOVE_KYUNGGONG_SYN;
	msg.dwObjectID = HEROID;
	msg.dwData1 = HEROID;


	VECTOR3 TargetPos;
	BOOL bTarget = FALSE;
	if(IsMoving(HERO))
	{
		bTarget = TRUE;
		TargetPos = *HERO->m_MoveInfo.GetTargetPosition(HERO->m_MoveInfo.GetCurTargetPosIdx());
	}
	
	HeroMoveStop();

	if(kgidx == 0)
	{
		msg.dwData2 = HERO->GetKyungGongGrade();
		SetKyungGong(HERO,HERO->GetKyungGongGrade());
	}
	else
	{
		msg.dwData2 = 0;
		SetKyungGong(HERO,0);
	}
	NETWORK->Send(&msg,sizeof(msg));


	if(bTarget)
	{
		SetHeroTarget(&TargetPos,FALSE);
	}
}


BYTE CMoveManager::GetMoveMode(CObject* pObject)
{
	return pObject->m_MoveInfo.MoveMode;
}

BOOL CMoveManager::IsMoving(CObject* pObject)
{
	return pObject->m_MoveInfo.bMoving;
}


void CMoveManager::NetworkMsgParse(BYTE Protocol,void* pMsg)
{
	switch(Protocol)
	{
	case MP_MOVE_TARGET:
		{
			MOVE_TARGETPOS* pmsg = (MOVE_TARGETPOS*)pMsg;
			CObject* pObject = OBJECTMGR->GetObject(pmsg->dwMoverID);
			if(pObject)
			{
				CalcPositionEx(pObject,gCurTime);
				pmsg->GetTargetInfo(&pObject->m_MoveInfo);
				VECTOR3 spos;
				pmsg->spos.Decompress(&spos);
				StartMoveEx(pObject, &spos, gCurTime);

/*
				GAMEIN->GetDebugDlg()->DebugMsgParser(DBG_MOVE,"MOVE_START ID: %d",pmsg->dwMoverID);
				GAMEIN->GetDebugDlg()->DebugMsgParser(DBG_MOVE,"sx : %4.2f    sz : %4.2f",pmsg->startx,pmsg->startz);
				GAMEIN->GetDebugDlg()->DebugMsgParser(DBG_MOVE,"tx : %4.2f    tz : %4.2f",pmsg->targetx,pmsg->targetz);
*/
				


				
			}
			else
			{
//				GAMEIN->GetDebugDlg()->DebugMsgParser(DBG_MOVE,"MOVE_START_NOOBJECT ID: %d",pmsg->dwMoverID);
#ifdef _GMTOOL_
				//镜单绝绰 皋技瘤甫 焊郴唱 犬牢秦焊磊.
				++GMTOOLMGR->m_nNullMove;
#endif				
			}
		}
		break;
// jsd
	case MP_MOVE_ONETARGET:
		{
			MOVE_ONETARGETPOS_FROMSERVER* pmsg = (MOVE_ONETARGETPOS_FROMSERVER*)pMsg;
			CObject* pObject = OBJECTMGR->GetObject(pmsg->dwObjectID);
			if(pObject)
			{
				CalcPositionEx(pObject,gCurTime);
				pmsg->GetTargetInfo(&pObject->m_MoveInfo);
				VECTOR3 spos;
				pmsg->GetStartPos(&spos);
				StartMoveEx(pObject, &spos, gCurTime);
			}
			else
			{
#ifdef _GMTOOL_
				//镜单绝绰 皋技瘤甫 焊郴唱 犬牢秦焊磊.
			++GMTOOLMGR->m_nNullMove;
#endif
			}
		}
		break;
//
	case MP_MOVE_STOP:
		{
			MOVE_POS* pmsg = (MOVE_POS*)pMsg;
			CObject* pObject = OBJECTMGR->GetObject(pmsg->dwMoverID);
			if(pObject)
			{
/*
				GAMEIN->GetDebugDlg()->DebugMsgParser(DBG_MOVE,"MOVE_STOP ID: %d",pmsg->dwMoverID);
				GAMEIN->GetDebugDlg()->DebugMsgParser(DBG_MOVE,"cx : %4.2f    cz : %4.2f",pObject->GetCurPosition().x,pObject->GetCurPosition().z);
				GAMEIN->GetDebugDlg()->DebugMsgParser(DBG_MOVE,"sx : %4.2f    sz : %4.2f",pmsg->x,pmsg->z);
*/

				VECTOR3 pos;
				pmsg->cpos.Decompress(&pos);
				CMoveManager::MoveStop(pObject,&pos);
			}
			else
			{
//				GAMEIN->GetDebugDlg()->DebugMsgParser(DBG_MOVE,"MOVE_STOP_NOOBJECT ID: %d",pmsg->dwMoverID);
			}
		}
		break;

	case MP_MOVE_WALKMODE:
		{
			MSGBASE* pmsg = (MSGBASE*)pMsg;
			CPlayer* pPlayer = (CPlayer*)OBJECTMGR->GetObject(pmsg->dwObjectID);
			if( pPlayer )
				SetWalkMode(pPlayer);

			PICONMGR->SetMoveState(pmsg->dwObjectID, eMoveMode_Walk);
		}
		break;
	
	case MP_MOVE_RUNMODE:
		{
			MSGBASE* pmsg = (MSGBASE*)pMsg;
			CPlayer* pPlayer = (CPlayer*)OBJECTMGR->GetObject(pmsg->dwObjectID);
			if( pPlayer )
				SetRunMode(pPlayer);

			PICONMGR->SetMoveState(pmsg->dwObjectID, eMoveMode_Run);
		}
		break;
	case MP_MOVE_MONSTERMOVE_NOTIFY:
		{
			MSG_WORD* pmsg = (MSG_WORD*)pMsg;
			CMonster* pMob = (CMonster*)OBJECTMGR->GetObject(pmsg->dwObjectID);
			BOOL rt = SetMonsterMoveType(pMob, pmsg->wData);
			//ASSERT(rt);
			
		}
		break;
	case MP_MOVE_KYUNGGONG_ACK:
		{
			MSG_DWORD2* pmsg = (MSG_DWORD2*)pMsg;

			PICONMGR->SetKyungGong(pmsg->dwData1, pmsg->dwData2);

			CPlayer* pPlayer = (CPlayer*)OBJECTMGR->GetObject(pmsg->dwData1);
			if(pPlayer == NULL)
				return;

			BOOL rt = SetKyungGong(pPlayer,(WORD)pmsg->dwData2);
			ASSERT(rt);			
		}
		break;

	case MP_MOVE_KYUNGGONG_NACK:
		{
			MSG_WORD* pmsg = (MSG_WORD*)pMsg;
			CHero* pHero = OBJECTMGR->GetHero();
			ASSERT(0);
		}
		break;
	case MP_MOVE_EFFECTMOVE:
		{
			/*
			MOVE_POS* pmsg = (MOVE_POS*)pMsg;
			CObject* pObject = OBJECTMGR->GetObject(pmsg->dwMoverID);
			if(pObject == NULL)
			{
				return;
			}
			VECTOR3 pos;
			pmsg->cpos.Decompress(&pos);
			EffectMoveInterpolation(pObject,&pos);
			*/
			//ASSERT(0);
		}
		break;	
	case MP_MOVE_CORRECTION:
		{	
			MOVE_POS* pmsg = (MOVE_POS*)pMsg;
			CObject* pObject = OBJECTMGR->GetObject(pmsg->dwMoverID);
			if(pObject == NULL)
			{
				return;
			}

			VECTOR3 pos;
			pmsg->cpos.Decompress(&pos);

			if(IsMoving(pObject))
				MoveStop(pObject,&pos);
			else
				SetPosition(pObject,&pos);
		}
		break;
	case MP_MOVE_FORCESTOPKYUNGGONG:
		{
			HERO->SetKyungGongMode(FALSE);
		}
		break;
		
	case MP_MOVE_WARP:
		{
			MOVE_POS* pmsg = (MOVE_POS*)pMsg;
			CObject* pObject = OBJECTMGR->GetObject(pmsg->dwMoverID);
			if(pObject == NULL)
				return;

			VECTOR3 pos;
			pmsg->cpos.Decompress(&pos);
			MoveStop( pObject, &pos );
			//warp俊 措茄 捞棋飘 荤侩?(肺弊牢 侩栏肺..)
		}
		break;
	}
}

void CMoveManager::RefreshHeroMove()
{
	if(IsMoving(HERO) == FALSE)
		return;

	VECTOR3 TargetPos = *HERO->m_MoveInfo.GetTargetPosition(HERO->m_MoveInfo.GetCurTargetPosIdx());
	SetHeroTarget(&TargetPos,FALSE);
}