mhcamera.cpp

墨香最新私服

	
	BASEMOVE_INFO moveinfo;
	moveinfo.bMoving = FALSE;				
	moveinfo.KyungGongIdx = 0;
	moveinfo.MoveMode = eMoveMode_Run;
	moveinfo.CurPosition.x = pCurCamera->m_CameraPos.x;
	moveinfo.CurPosition.z = pCurCamera->m_CameraPos.z;	
	MOVEMGR->InitMove(HERO, &moveinfo);

	// 辑滚俊 某腐磐狼 捞悼阑 舅妨 弊府靛 沥焊甫 盎脚茄促.	
	if( (gCurTime-m_LastMoveNoticeTime) >= 300 )
	{
		MOVE_ONETARGETPOS msg;
		msg.Category = MP_MOVE;
		msg.Protocol = MP_MOVE_ONETARGET;
		msg.dwObjectID = HEROID;
		msg.dwMoverID = HEROID;
		msg.SetStartPos( &pCurCamera->m_CameraPos );
		msg.SetTargetPos( &pCurCamera->m_CameraPos );		
		NETWORK->Send(&msg,msg.GetSize());
		
		m_LastMoveNoticeTime = gCurTime;
	}	
}


#define MOUSEROTATE_RATE 0.3f

void CMHCamera::MouseRotate(int x, int y)
{
	m_CameraDesc[m_CurCamera].m_AngleX.SetAngleDeg(m_CameraDesc[m_CurCamera].m_AngleX.ToDeg() - y * MOUSEROTATE_RATE);
	m_CameraDesc[m_CurCamera].m_AngleY.SetAngleDeg(m_CameraDesc[m_CurCamera].m_AngleY.ToDeg() + x * MOUSEROTATE_RATE);
}

void CMHCamera::SetCurCamera(int Camera)
{
	ASSERT(Camera >= 0 && Camera < MAX_CAMERA_DESC);
	m_CurCamera = Camera;
}

void CMHCamera::SetCameraPivotObject(int Camera,CObject* pObject)
{
	if(pObject)
		m_CameraDesc[Camera].m_bPivotObject = TRUE;
	else
		m_CameraDesc[Camera].m_bPivotObject = FALSE;
	m_CameraDesc[Camera].m_pPivotObject = pObject;
}
void CMHCamera::SetCameraPivotPos(int Camera,VECTOR3* pPos)
{
	m_CameraDesc[Camera].m_PivotPos = *pPos;
}


void CMHCamera::Rotate(int Camera,float RotateAngle,DWORD Duration)
{
	if(m_CameraDesc[Camera].m_bCameraAngleMovingY)	// 雀傈吝捞菌促搁
	{
		m_CameraDesc[Camera].m_AngleY.Process(1);
	}

	m_CameraDesc[Camera].m_AngleY.SetRotateDeg(RotateAngle);
	m_CameraDesc[Camera].m_bCameraAngleMovingY = TRUE;
	m_CameraDesc[Camera].m_CameraAngleMoveStartY = gCurTime;
	m_CameraDesc[Camera].m_CameraAngleMoveDurationY = Duration;	
}

void CMHCamera::SetTargetAngleX(int Camera,float fAngleX,DWORD Duration)
{
	if(m_CameraDesc[Camera].m_bCameraAngleMovingX)	// 雀傈吝捞菌促搁
	{
		m_CameraDesc[Camera].m_AngleX.Process(1);
	}
	
	m_CameraDesc[Camera].m_AngleX.SetTargetDeg(fAngleX);
	m_CameraDesc[Camera].m_bCameraAngleMovingX = TRUE;
	m_CameraDesc[Camera].m_CameraAngleMoveStartX = gCurTime;
	m_CameraDesc[Camera].m_CameraAngleMoveDurationX = Duration;
}

void CMHCamera::SetTargetAngleY(int Camera,float fAngleY,DWORD Duration)
{
	if(m_CameraDesc[Camera].m_bCameraAngleMovingY)	// 雀傈吝捞菌促搁
	{
		m_CameraDesc[Camera].m_AngleY.Process(1);
	}
	
	m_CameraDesc[Camera].m_AngleY.SetTargetDeg(fAngleY);
	m_CameraDesc[Camera].m_bCameraAngleMovingY = TRUE;
	m_CameraDesc[Camera].m_CameraAngleMoveStartY = gCurTime;
	m_CameraDesc[Camera].m_CameraAngleMoveDurationY = Duration;
}

void CMHCamera::SetDistance(int Camera,float fDistance,DWORD Duration)
{
	float fChange = fDistance - m_CameraDesc[Camera].m_fDistance;
	ZoomDistance(Camera,fChange,Duration);
}

void CMHCamera::ZoomDistance(int Camera,float fDistanceChange,DWORD Duration)
{
	m_CameraDesc[Camera].m_fDistanceStart = m_CameraDesc[Camera].m_fDistance;
	m_CameraDesc[Camera].m_fDistanceChange = fDistanceChange;
	m_CameraDesc[Camera].m_bCameraDistanceMoving = TRUE;
	m_CameraDesc[Camera].m_CameraDistanceMoveStart = gCurTime;
	m_CameraDesc[Camera].m_CameraDistanceMoveDuration = Duration;
}

// 泅犁 墨皋扼俊辑 促弗 墨皋扼肺 何靛反霸 捞悼茄促.
void CMHCamera::ChangeCameraSmooth(int Camera,DWORD Duration)
{
	MHCAMERADESC tempdesc;
	memcpy(&tempdesc,&m_CameraDesc[Camera],sizeof(MHCAMERADESC));
	memcpy(&m_CameraDesc[Camera],&m_CameraDesc[m_CurCamera],sizeof(MHCAMERADESC));
	StopAllMoving(Camera);
	SetTargetAngleX(Camera,tempdesc.m_AngleX.ToDeg(),Duration);
	SetTargetAngleY(Camera,tempdesc.m_AngleY.ToDeg(),Duration);
	
}
	
// 泅犁 墨皋扼狼 汲沥蔼阑 弊措肺 0锅 墨皋扼俊 悸泼茄促.
void CMHCamera::ChangeToDefaultCamera()
{
	memcpy(&m_CameraDesc[0],&m_CameraDesc[m_CurCamera],sizeof(MHCAMERADESC));
	StopAllMoving(0);
	SetCurCamera(0);
}


// 雀傈捞唱 淋殿阑 肛冕促
void CMHCamera::StopAllMoving(int Camera)
{
	m_CameraDesc[Camera].m_bCameraAngleMovingX = FALSE;
	m_CameraDesc[Camera].m_bCameraAngleMovingY = FALSE;
	m_CameraDesc[Camera].m_bCameraDistanceMoving = FALSE;
}



//////////////////////////////////////////////////////////////////////////
// 柳悼扁瓷阑 困茄 窃荐甸
void CMHCamera::SetPushedVibration(VECTOR3* PushedVector,DWORD Duration)
{
	SetVector3(&m_VibratePos,0,0,0);
	SetVector3(&m_VibrateAngle,0,0,0);
	m_PushedVector = *PushedVector;
	m_VibrateStartTime = gCurTime;
	m_VibrateDuration = Duration;
	m_bIsVibrating = TRUE;
}

void CMHCamera::CalcVibration()
{
	if(m_bIsVibrating == FALSE)
		return;

	DWORD elapsedTime = gCurTime - m_VibrateStartTime;
	float fElapsedRate = elapsedTime / (float)m_VibrateDuration;
	
	if(fElapsedRate >= 1)
	{
		fElapsedRate = 1;
		m_bIsVibrating = 0;
	}

	m_VibratePos = m_PushedVector * (1 - fElapsedRate);
}
//////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////
// 溅捞欧 扁瓷阑 困茄 窃荐甸
void CMHCamera::SetShaking(int ShakeNum, float amp)
{
	ASSERT(ShakeNum >= 0);
	ASSERT(ShakeNum < eCSD_Max);

	m_bIsShaking = TRUE;
	m_nCurShakingNum = ShakeNum;
	m_CurShakingPos = 0;
	m_LastShakingPosChangedTime = gCurTime;
	m_Amplitude = amp;
}

void CMHCamera::CalcShaking()
{
	if(m_bIsShaking == FALSE)
		return;

	DWORD elapsedTime = gCurTime - m_LastShakingPosChangedTime;
	MHCAMERASHAKE* pCurShake = m_ppCameraShakeDesc[m_nCurShakingNum];
	SHAKEVECTOR* pCurVector = &pCurShake->pShakeVector[m_CurShakingPos];
	if(elapsedTime >= pCurVector->Duration)
	{
		m_LastShakingPosChangedTime = gCurTime;
		if(++m_CurShakingPos >= pCurShake->MaxShakeVector)
		{
			m_bIsShaking = FALSE;
			return;
		}

		pCurVector = &pCurShake->pShakeVector[m_CurShakingPos];
	}

	m_ShakingPos = pCurVector->ShakeVector * m_Amplitude;
}
//////////////////////////////////////////////////////////////////////////

void CMHCamera::SetCameraMode(int CameraMode)
{
	m_CurCameraMode = CameraMode;
	switch(CameraMode)
	{
	case eCM_Free:
		{
			//SetDistance( m_CurCamera, 1000, 0 );
			m_CameraDesc[m_CurCamera].m_fDistance += 1;
			m_fAddHeight = 0;
		}
		break;
	case eCM_QuarterView:
		{
			SetTargetAngleX(0,30,500);
			SetTargetAngleY(0,0,500);
			SetDistance(0,1000,500);			
		}
		break;
	case eCM_FollowView:
		{
//			float angle;
//			if(m_CameraDesc[0].m_bPivotObject)
//				angle = m_CameraDesc[0].m_pPivotObject->GetAngle();
//			else
//				angle = 0;

//			SetTargetAngleX(0,DEFAULT_ANGLEX_FOLLOW_VIEW,500);
//			SetTargetAngleY(0,DEFAULT_ANGLEY_FOLLOW_VIEW+RADTODEG(angle),500);
//			SetDistance(0,DEFAULT_DISTANCE_FOLLOW_VIEW,500);
		}
		break;
	case eCM_EyeView:
		{
			m_CameraDesc[m_CurCamera].m_fDistance -= 1;
			m_fAddHeight = 0;
		}
		break;
	}
}


void CMHCamera::ToggleCameraViewMode()
{
	if( m_CurCameraMode == eCM_Free )
		SetCameraMode( eCM_FollowView );
	else
		SetCameraMode( eCM_Free );
}


void CMHCamera::ProcessCameraMode()
{
	switch(m_CurCameraMode)
	{
	case eCM_Free:
		{

		}
		break;
	case eCM_QuarterView:
		{		
		}
		break;
	case eCM_FollowView:
		{
			if(m_CameraDesc[0].m_bPivotObject == FALSE)
				break;
			
//			if(MOVEMGR->IsMoving(m_CameraDesc[0].m_pPivotObject) == FALSE)
//			{
//				break;
//			}
			if( m_CameraDesc[0].m_bCameraAngleMovingX || 
				m_CameraDesc[0].m_bCameraAngleMovingY || 
				m_CameraDesc[0].m_bCameraDistanceMoving)
				break;	

			if( !g_UserInput.GetMouse()->RButtonPressed()
				&& !g_UserInput.GetKeyboard()->GetKeyPressed( KEY_LEFT )
				&& !g_UserInput.GetKeyboard()->GetKeyPressed( KEY_RIGHT ) )
				FollowCamera();
		}
		break;
	case eCM_EyeView:
		{
		}
		break;
	}
}

void CMHCamera::ProcessCameraMoving()
{
	MHCAMERADESC* pDesc;
	for(int n=0;n<MAX_CAMERA_DESC;++n)
	{
		pDesc = &m_CameraDesc[n];

		if(pDesc->m_bCameraAngleMovingX)
		{
			float fRate;
			DWORD MoveTime = gCurTime - pDesc->m_CameraAngleMoveStartX;
			if(pDesc->m_CameraAngleMoveDurationX == 0)
				fRate = 1.0f;
			else
				fRate = MoveTime / (float)pDesc->m_CameraAngleMoveDurationX;
			if(fRate >= 1.0f)
			{
				fRate = 1.0f;
				pDesc->m_bCameraAngleMovingX = FALSE;
			}
			pDesc->m_AngleX.Process(fRate);
		}
		if(pDesc->m_bCameraAngleMovingY)
		{
			float fRate;
			DWORD MoveTime = gCurTime - pDesc->m_CameraAngleMoveStartY;
			if(pDesc->m_CameraAngleMoveDurationY == 0)
				fRate = 1.0f;
			else
				fRate = MoveTime / (float)pDesc->m_CameraAngleMoveDurationY;
			if(fRate >= 1.0f)
			{
				fRate = 1.0f;
				pDesc->m_bCameraAngleMovingY = FALSE;
			}
			pDesc->m_AngleY.Process(fRate);
		}
		if(pDesc->m_bCameraDistanceMoving)
		{
			float fRate;
			DWORD MoveTime = gCurTime - pDesc->m_CameraDistanceMoveStart;
			if(pDesc->m_CameraDistanceMoveDuration == 0)
				fRate = 1.0f;
			else
				fRate = MoveTime / (float)pDesc->m_CameraDistanceMoveDuration;
			if(fRate >= 1.0f)
			{
				fRate = 1.0f;
				pDesc->m_bCameraDistanceMoving = FALSE;
			}
			pDesc->m_fDistance = pDesc->m_fDistanceStart + pDesc->m_fDistanceChange*fRate;
		}
		if(pDesc->m_bHeightChanging)
		{
			float fRate;
			DWORD MoveTime = gCurTime - pDesc->m_dwHeightStartTime;
			if(pDesc->m_dwHeightChangeDuration == 0)
				fRate = 1.0f;
			else
				fRate = MoveTime / (float)pDesc->m_dwHeightChangeDuration;
			if(fRate >= 1.0f)
			{
				fRate = 1.0f;
				pDesc->m_bHeightChanging = FALSE;
			}
			pDesc->m_CharHeight = pDesc->m_StartCharHeight + (pDesc->m_TargetCharHeight - pDesc->m_StartCharHeight)*fRate;
		}
	}
}

void CMHCamera::RestrictCameraAngleDistance()
{
	if(m_CurCameraMode == eCM_LOGIN)
		return;

	MHCAMERADESC* pDesc = &m_CameraDesc[m_CurCamera];
	
#ifndef _TESTCLIENT_
	//////////////////////////////////////////////////////////////////////////
	// AngleX
	float angleX = pDesc->m_AngleX.ToDeg();
	if(angleX > 180)
		angleX -= 360;

	if(angleX < GAMERESRCMNGR->m_GameDesc.CameraMinAngleX)
	{
		pDesc->m_AngleX.SetAngleDeg(GAMERESRCMNGR->m_GameDesc.CameraMinAngleX);
	}
	else if(angleX > GAMERESRCMNGR->m_GameDesc.CameraMaxAngleX)
	{
		pDesc->m_AngleX.SetAngleDeg(GAMERESRCMNGR->m_GameDesc.CameraMaxAngleX);
	}


	//////////////////////////////////////////////////////////////////////////
	// AngleY

	//////////////////////////////////////////////////////////////////////////
	// Distance
	if(pDesc->m_fDistance < GAMERESRCMNGR->m_GameDesc.CameraMinDistance)
	{
		pDesc->m_fDistance = GAMERESRCMNGR->m_GameDesc.CameraMinDistance;
	}
	if(pDesc->m_fDistance > GAMERESRCMNGR->m_GameDesc.CameraMaxDistance)
	{
		pDesc->m_fDistance = GAMERESRCMNGR->m_GameDesc.CameraMaxDistance;
	}
#endif
}

void CMHCamera::FollowCamera()
{
	float fRate = gTickTime * 0.005f;
	if(fRate > 1)
		fRate = 1;
	
	MHCAMERADESC* pDesc = &m_CameraDesc[0];
	float angle = pDesc->m_pPivotObject->GetAngle();
	
//	pDesc->m_AngleX.SetTargetDeg(DEFAULT_ANGLEX_FOLLOW_VIEW);
//	pDesc->m_AngleX.Process(fRate);

	pDesc->m_AngleY.SetTargetDeg(DEFAULT_ANGLEY_FOLLOW_VIEW+RADTODEG(angle));
	pDesc->m_AngleY.Process(fRate);

//	float target = DEFAULT_DISTANCE_FOLLOW_VIEW;
//	pDesc->m_fDistance = target * fRate + pDesc->m_fDistance * (1-fRate);
}


void CMHCamera::SetSightDistanceRate( float fDistanceRate )
{
	if( m_fDistanceRate == fDistanceRate )	return;

	m_fDistanceRate = fDistanceRate;
	m_EngineCamera.ResetCamera( m_fMaxSightDistance * fDistanceRate / 100.0f, m_fFov );	
}

void CMHCamera::SetCharState( int eCharState, DWORD dwDuration )
{
	MHCAMERADESC* pCurCamera = &m_CameraDesc[m_CurCamera];

	pCurCamera->m_bHeightChanging	= TRUE;
	pCurCamera->m_dwHeightStartTime = gCurTime;
	pCurCamera->m_dwHeightChangeDuration = dwDuration;
	pCurCamera->m_StartCharHeight = pCurCamera->m_CharHeight;
	switch( eCharState )
	{
	case eCS_Sit:
		pCurCamera->m_TargetCharHeight = SITHEIGHT;
		break;
	case eCS_Die:
		pCurCamera->m_TargetCharHeight = DIEHEIGHT;
		break;
	case eCS_Normal:
		pCurCamera->m_TargetCharHeight = CHARHEIGHT;		
		break;
	default:
		pCurCamera->m_TargetCharHeight = CHARHEIGHT;
		break;
	}
}

void CMHCamera::Fly( float fFly )
{
	m_fAddHeight += fFly/2;
	if( m_fAddHeight > 5000 )
		m_fAddHeight = 5000;
	else if( m_fAddHeight < 0 )
	{
		m_fAddHeight = 0;
	}
}