C++ CServerDE::GetRotationVectors方法代码示例

DBOOL CHandWeaponModel::Update()
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return 0;

	if (m_bFirstUpdate)
	{
		m_bFirstUpdate = DFALSE;

		DDWORD dwFlags = pServerDE->GetObjectFlags(m_hObject);

		if (m_bVisible)
			pServerDE->SetObjectFlags(m_hObject, dwFlags | FLAG_VISIBLE);
		else
			pServerDE->SetObjectFlags(m_hObject, dwFlags & ~FLAG_VISIBLE);

		if( !m_bDropped )
		{
			pServerDE->SetNextUpdate(m_hObject, 0.0f);
			return DTRUE;
		}
	}

	// See if standing on anything
	CollisionInfo collisionInfo;

	pServerDE->GetStandingOn(m_hObject, &collisionInfo);
	DBOOL bIsStandingOn = (collisionInfo.m_hObject != DNULL);

	if (bIsStandingOn)
	{
		// Spawn a powerup
		DVector vF, vPos, vU;
		DRotation rRot;

		// We want the rotation aligned.
		pServerDE->GetObjectRotation(m_hObject, &rRot);
		pServerDE->GetRotationVectors(&rRot, &vU, &vPos, &vF);
		vF.y = 0.0f;
		VEC_SET(vU, 0,1,0);
		pServerDE->AlignRotation(&rRot, &vF, &vU);

		pServerDE->GetObjectPos(m_hObject, &vPos);
		vPos.y += 10;

		SpawnWeaponPickup(m_dwType, m_hObject, &vPos, &rRot, !m_bOwnedByPlayer);

		return DFALSE;
	}

	pServerDE->SetNextUpdate( m_hObject, 0.01f);

	return DTRUE;
}

void CHandWeaponModel::Drop()
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;

	m_bDropped = DTRUE;

	DVector vF, vR, vU;
	DRotation rRot;

	// Set some minimum dims, and make sure x and z are the same.
	DVector vDims;
	pServerDE->GetModelAnimUserDims(m_hObject, &vDims, pServerDE->GetModelAnimation(m_hObject));
	if (vDims.x < 10.0f)
		vDims.x = 10.0f;
	if (vDims.x > vDims.z)
		vDims.z = vDims.x;
	else 
		vDims.x = vDims.z;

//	g_pServerDE->BPrint("Setting PU dims %f,%f,%f", VEC_EXPAND(vDims));
	if (pServerDE->SetObjectDims2(m_hObject, &vDims) == DE_ERROR)

	// Get vectors to set a velocity	
	pServerDE->GetObjectRotation(m_hObject, &rRot);
	pServerDE->GetRotationVectors(&rRot, &vU, &vR, &vF);

	// Set some forward and upward velocity
	VEC_ADD(vF, vF, vU);
	VEC_MULSCALAR(vF, vF, 150.0f);

	pServerDE->SetVelocity(m_hObject, &vF);

	// Make it visible
	DDWORD dwFlags = pServerDE->GetObjectFlags(m_hObject);
	pServerDE->SetObjectFlags(m_hObject, dwFlags | FLAG_NOSLIDING | FLAG_VISIBLE | FLAG_GRAVITY | FLAG_REMOVEIFOUTSIDE);

	// Show the model on the client now
/*	if(m_dwClientID)
	{
		HMESSAGEWRITE hMsg = pServerDE->StartSpecialEffectMessage(this);
		pServerDE->WriteToMessageByte(hMsg, SFX_WEAPONHANDMODEL_ID);
		pServerDE->WriteToMessageDWord(hMsg, m_dwClientID);
		pServerDE->WriteToMessageByte(hMsg, (m_bLeftHand << 1) | DTRUE);
		pServerDE->EndMessage2(hMsg, MESSAGE_GUARANTEED);
	}
*/
	// Set next update for 1 second to spawn a powerup
	pServerDE->SetNextUpdate( m_hObject, 1.0f);
}

void CMovement::Update()
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE || !m_hObject) return;

    // Save our last position...
	VEC_COPY(m_vLastPos,m_vPos);
	pServerDE->GetObjectPos(m_hObject, &m_vPos);

	// Retrieve object vectors for current frame..
	pServerDE->GetObjectRotation(m_hObject, &m_rRot);
	pServerDE->GetRotationVectors(&m_rRot, &m_vUp, &m_vRight, &m_vForward);

	return;
}

DBOOL CMovement::ClearToPoint(DVector vStart, DVector vDestPos, DVector vDims, IntersectInfo* IInfo)
{
	GlobalFilterFnData globalFilterFnData;
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE) return DFALSE;

	DFLOAT fDim = (DFLOAT)sqrt((vDims.x * vDims.x) + (vDims.z * vDims.z)) + 0.1f;

	IntersectQuery IQuery;

	IQuery.m_Flags	  = INTERSECT_OBJECTS | IGNORE_NONSOLID;
	IQuery.m_FilterFn = GlobalFilterFn;
	globalFilterFnData.m_dwFlags = IGNORE_CHARACTER;
	globalFilterFnData.m_nIgnoreObjects = 1;
	globalFilterFnData.m_hIgnoreObjects = &m_hObject;
	IQuery.m_pUserData = &globalFilterFnData;	

	DVector vDir;
	DRotation rRot;

	VEC_SUB(vDir, vDestPos, vStart);
	VEC_NORM(vDir);

	pServerDE->AlignRotation(&rRot, &vDir, &m_vUp);

	DVector vU,vR,vF;
	pServerDE->GetRotationVectors(&rRot,&vU,&vR,&vF);

	//check the right side
	VEC_ADDSCALED(IQuery.m_From, vStart, vR, fDim);
	VEC_ADDSCALED(IQuery.m_To, vDestPos, vR, fDim);

	if(pServerDE->IntersectSegment(&IQuery, IInfo))
	{
		return DFALSE;
	}

	//check the left side
	VEC_ADDSCALED(IQuery.m_From, vStart, vR, (fDim * -1.0f));
	VEC_ADDSCALED(IQuery.m_To,vDestPos, vR, (fDim * -1.0f));

	if(pServerDE->IntersectSegment(&IQuery, IInfo))
	{
		return DFALSE;
	}

	return DTRUE;
}

DDWORD BugAI::EngineMessageFn(DDWORD messageID, void *pData, DFLOAT fData)
{
	switch(messageID)
	{
		case MID_PRECREATE:
		{
			// Need to call base class to have the object name read in before
			// we call PostPropRead()

			DDWORD dwRet = AI_Mgr::EngineMessageFn(messageID, pData, fData);

			if (fData == 1.0)
				AI_Mgr::ReadProp((ObjectCreateStruct*)pData);  // inside BaseCharacter

			PostPropRead((ObjectCreateStruct*)pData);

			return dwRet;
		}
		break;
        
		case MID_INITIALUPDATE:
		{
			InitialUpdate((DVector *)pData);
			break;
		}

		case MID_UPDATE:
		{
			CServerDE* pServerDE = GetServerDE();
			if (!pServerDE) return 0;

			//gotta keep the bug stuck to whatever surface it is on
			DRotation rRot;
			DVector vU,vR,vF,vVel,vPos;

			pServerDE->GetObjectPos(m_hObject,&vPos);
			pServerDE->GetObjectRotation(m_hObject,&rRot);
			pServerDE->GetRotationVectors(&rRot,&vU,&vR,&vF);
			VEC_MULSCALAR(vVel,vU,-15.0f);

			Move(vVel, MATH_EPSILON);

			//check if there is something below, if not rotate
			IntersectQuery IQuery;
			IntersectInfo ii;
	
			IQuery.m_Flags	  = INTERSECT_OBJECTS;
			IQuery.m_FilterFn = DNULL;

			DVector vTemp;
			VEC_MULSCALAR(vTemp,vU,-2.0f);
			VEC_COPY(IQuery.m_From,vPos);
			VEC_ADD(IQuery.m_To,IQuery.m_From,vTemp);

			if(pServerDE->IntersectSegment(&IQuery, &ii))
			{
				DRotation rRot;
				DVector vDown;

				VEC_MULSCALAR(vDown,vU,-1.0f);
				pServerDE->AlignRotation(&rRot,&vDown,&vF);

				pServerDE->SetObjectRotation(m_hObject,&rRot);
			}
		}
		break;

		default : break;
	}


	return AI_Mgr::EngineMessageFn(messageID, pData, fData);
}

void CDestructable::HandleDamage(HOBJECT hSender, HMESSAGEREAD hRead)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE) return;

	DVector vDir,vPos;

	pServerDE->ReadFromMessageVector(hRead, &vDir);
	DFLOAT fDamage = pServerDE->ReadFromMessageFloat(hRead);
	DBYTE nDamageType	= pServerDE->ReadFromMessageByte(hRead);
	HOBJECT hWhoHit = pServerDE->ReadFromMessageObject(hRead);
	pServerDE->ReadFromMessageVector(hRead, &vPos);

//	char buf[50];
	DFLOAT fOldHitPoints = m_fHitPoints;
	fDamage = fDamage * m_fResistance;

	// Just return if we can't take damage
	if (m_bGodMode || (m_bTriggerOnly && nDamageType != DAMAGE_TYPE_DEATH) || fDamage < 0)
	{
		return;
	}

	if (!IsPlayerToPlayerDamageOk(hSender, hWhoHit))
	{
		return;
	}

	// If instant death, don't bother calculating stuff.. 
	if( m_bDestructable && nDamageType == DAMAGE_TYPE_DEATH)
	{
		m_fArmorPoints = 0;
		m_fHitPoints = 0;
		m_fDeathHitPoints = 0;
		m_fLastDamagePercent = 100.0f;
		m_fLastDamageAmount = (DFLOAT)m_fMaxHitPoints;

		nDamageType &= 0x0f;	// Mask off the damage type flags
		m_nLastDamageType = nDamageType;
	}
	else
	{
		// Special pre-damage base character modifiers
		if (IsAICharacter(m_hObject))
		{
			m_nNodeHit = CalculateHitLimb(vDir,vPos,fDamage);

			if(m_nNodeHit == -1 && !(nDamageType & DAMAGE_TYPE_NORMAL))
				m_nNodeHit = SetProperNode(pServerDE->IntRandom(0,NUM_ALL_NODES - 3));
			else if(m_nNodeHit >= 0)
				m_nNodeHit = SetProperNode(m_nNodeHit);
			else
				return;

			//Compute one side got hit for recoils
			DVector vU, vR, vF, vTmpDir;
			DRotation rRot;
			pServerDE->GetObjectRotation(m_hObject, &rRot);
			pServerDE->GetRotationVectors(&rRot, &vU, &vR, &vF);

			VEC_COPY(vTmpDir, vDir);

			VEC_MULSCALAR(vTmpDir,vTmpDir,-1.0f);
			DFLOAT fAmount = (DFLOAT) atan2(vTmpDir.x, vTmpDir.z);    
			DFLOAT fAmount2 = (DFLOAT) atan2(vF.x, vF.z);

			if(fAmount < 0.0f)
				fAmount = (MATH_PI*2) + fAmount;
			if(fAmount2 < 0.0f)
				fAmount2 = (MATH_PI*2) + fAmount2;

			DFLOAT fAngle = fAmount2 - fAmount;

			if(fAngle <= MATH_PI/2 || fAngle >= 3*MATH_PI/2)	//Hit the front
			{
				m_nSideHit = 0;
			}
			else //Hit the back
			{
				m_nSideHit = 6;	
			}

			if (m_hLastDamager)
				pServerDE->BreakInterObjectLink(m_hObject, m_hLastDamager);

			m_hLastDamager = hWhoHit;

			if(m_hLastDamager)
				pServerDE->CreateInterObjectLink(m_hObject, m_hLastDamager);

			if(m_nNodeHit == NODE_NECK)
			{
				AI_Mgr* pAI = (AI_Mgr*)pServerDE->HandleToObject(m_hObject);

				if(pAI->m_bCabal || pServerDE->IsKindOf(pServerDE->GetObjectClass(m_hObject), pServerDE->GetClass("SoulDrudge")))
					m_fHitPoints = 0;
				
				fDamage *= 1.5f;
			}
			else if(m_nNodeHit == NODE_TORSO)
//.........这里部分代码省略.........

//.........这里部分代码省略.........
            DVector m_vUp, m_vRight, m_vForward;
            DVector vPos, vTemp, vDir, vDims;

// Need to build a table of Sprites and There Positions...
// Then Update Each position???
//
            int x = m_nFireIndex;
            
            {
            	// Remove everything if we're done.
            	if (fTime > m_fStartTime[x] + m_fDuration[x])
        	    {
            
        	        m_fStartTime[x] = pServerDE->GetTime();
            
    		        if (m_hSprite[x]) 
					{
						g_pServerDE->RemoveObject(m_hSprite[x]);
						m_hSprite[x] = DNULL;
					}
    		        if (m_hSmokeTrail[x])
					{
						g_pServerDE->RemoveObject(m_hSmokeTrail[x]);
						m_hSmokeTrail[x] = DNULL;
					}
                
                    // Add Flame
                    VEC_INIT(m_vUp);
            	    VEC_INIT(m_vRight);
                	VEC_INIT(m_vForward);

                    if (!m_hLinkObject) return DFALSE;
            	    pServerDE->GetObjectRotation(m_hLinkObject, &rRot);
                	pServerDE->GetRotationVectors(&rRot, &m_vUp, &m_vRight, &m_vForward);    

                    if (!m_hLinkObject) return DFALSE;
             	    pServerDE->GetObjectDims(m_hLinkObject, &vDims);
                	pServerDE->GetObjectPos(m_hLinkObject, &vPos);
                    
                    // Need to use the Dims of the Object to set these!!!
					VEC_MULSCALAR(vDims, vDims, 0.8f);
                    DFLOAT m_fForwardOffset = pServerDE->Random(-vDims.x, vDims.x);
                    DFLOAT m_fUpOffset = pServerDE->Random(-vDims.y, vDims.y/2.0f);
                    DFLOAT m_fRightOffset = pServerDE->Random(-vDims.z, vDims.z);
    
    	            VEC_MULSCALAR(vTemp, m_vForward, m_fForwardOffset);
        	        VEC_ADD(vPos, vPos, vTemp);
    
                    // vPos is a point in front of you.
                    // vDir is a point in front of you, but down
        	        VEC_COPY(vDir, vPos);
                	vDir.y = vDir.y - m_fUpOffset;
                	vDir.x = vDir.x - m_fRightOffset;
					vDir.z = vDir.z - m_fForwardOffset;
                
            	    VEC_COPY(vPos, vDir);

                    ObjectCreateStruct theStruct;
                    INIT_OBJECTCREATESTRUCT(theStruct);

                    theStruct.m_Flags = FLAG_VISIBLE;
                    theStruct.m_ObjectType = OT_SPRITE; 
					VEC_COPY(theStruct.m_Pos, vPos);

        			theStruct.m_SkinName[0] = '\0';
	        		theStruct.m_NextUpdate = 0.0f;

DVector CMovement::FindShortestTurn(DVector vStart, DRotation* prRot, DFLOAT fMoveLen)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE) return vStart;

	DVector vDir, vEnd, vCurPos;
	DVector vUp,vRight,vForward,vLeft;

	VEC_COPY(vCurPos, vStart);

	IntersectQuery IQuery;
	IntersectInfo ii;

	DFLOAT fLeftDist = 0.0f, fRightDist = 0.0f, fMaxDist = 0.0f;

	pServerDE->GetRotationVectors(prRot,&vUp,&vRight,&vForward);
	VEC_MULSCALAR(vLeft,vRight,-1.0f);		//create the left rotation vector

	IQuery.m_Flags	  = INTERSECT_OBJECTS | IGNORE_NONSOLID;
	IQuery.m_FilterFn = DNULL;

	//get the farthest left we could travel
	VEC_COPY(IQuery.m_From,vCurPos);
	VEC_COPY(IQuery.m_Direction,vLeft);

	if(pServerDE->CastRay(&IQuery,&ii))
	{
		fMaxDist = fLeftDist = VEC_DIST(vCurPos,ii.m_Point);
	}

	//now get the farthest right
	VEC_COPY(IQuery.m_Direction,vRight);

	if(pServerDE->CastRay(&IQuery,&ii))
	{
		fRightDist = VEC_DIST(vCurPos,ii.m_Point);

		if(fRightDist > fMaxDist)
			fMaxDist = fRightDist;
	}

	//travel the obstacle in both directions looking for a clearing
	VEC_INIT(vDir);

	VEC_MULSCALAR(vEnd,vForward,fMoveLen + 5.0f);

	for(float fWidth = fMoveLen; !(fWidth >= fRightDist && fWidth >= fLeftDist); fWidth += fMoveLen)
	{
		//Check the right side
		if(fWidth < fRightDist)
		{
			VEC_ADDSCALED(IQuery.m_From,vCurPos,vRight,fWidth);
			VEC_ADD(IQuery.m_To,IQuery.m_From,vEnd);

			if(!pServerDE->IntersectSegment(&IQuery,&ii))
			{
				VEC_ADDSCALED(IQuery.m_From,IQuery.m_From,vRight,fWidth/2);
				pServerDE->AlignRotation(prRot, &vLeft, &m_vUp);
				return IQuery.m_From;
			}
		}

		//Check the left side
		if(fWidth < fLeftDist)
		{
			VEC_ADDSCALED(IQuery.m_From,vCurPos,vLeft,fWidth);
			VEC_ADD(IQuery.m_To,IQuery.m_From,vEnd);

			if(!pServerDE->IntersectSegment(&IQuery,&ii))
			{
				VEC_ADDSCALED(IQuery.m_From,IQuery.m_From,vLeft,fWidth/2);
				pServerDE->AlignRotation(prRot, &vRight, &m_vUp);
				return IQuery.m_From;
			}

		}
	}

	return vStart;
}

DBOOL CMovement::CalculatePath(DVector vDestPos)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE) return DFALSE;

	DVector vDims, vTest;
	DRotation rRot;

	//sanity check to make sure vDestPos is valid
	VEC_INIT(vTest);
	if(VEC_DIST(vTest, vDestPos) <= 0)
		return DFALSE;

	IntersectQuery IQuery;
	IntersectInfo IInfo;

	IQuery.m_Flags	  = INTERSECT_OBJECTS;
	IQuery.m_FilterFn = DNULL;

//	LARGE_INTEGER start;
//	QueryPerformanceCounter(&start);

	//clear the path list out
	Term();

	//get the parent's dims
	pServerDE->GetObjectDims(m_hObject,&vDims);
	DFLOAT fDim = (DFLOAT)sqrt((vDims.x * vDims.x) + (vDims.z * vDims.z)) + 0.1f;

	if(!ClearToPoint(m_vPos, vDestPos,vDims, &IInfo))
	{
		VEC_ADDSCALED(IInfo.m_Point,IInfo.m_Point, IInfo.m_Plane.m_Normal, fDim - 0.1f)

		AddPosToPathList(IInfo.m_Point);

		//align a test rotation to the obstacles normal and retrieve the rotation vectors
		VEC_MULSCALAR(IInfo.m_Plane.m_Normal, IInfo.m_Plane.m_Normal, -1.0f);
		pServerDE->AlignRotation(&rRot, &(IInfo.m_Plane.m_Normal), &m_vUp);

		DVector vTurnPoint = FindShortestTurn(IInfo.m_Point, &rRot, fDim);

		if(VEC_DIST(vTurnPoint, IInfo.m_Point) <= 0.0f)
			return DFALSE;

		AddPosToPathList(vTurnPoint);

		DVector vU,vR,vF;
		pServerDE->GetRotationVectors(&rRot,&vU,&vR,&vF);

		vTurnPoint = FindTurn(vTurnPoint, vF, IInfo.m_Plane.m_Normal, fDim, fDim);
		
		if(VEC_DIST(vTurnPoint, vDestPos) <= 0.0f)
			return DFALSE;

		if(ClearToPoint(vTurnPoint, vDestPos, vDims, &IInfo))
		{
			AddPosToPathList(vTurnPoint);
			AddPosToPathList(vDestPos);

//			ConsolidatePath();
		}
		else
			return DFALSE;
	}
	else
		AddPosToPathList(vDestPos);

/*	LARGE_INTEGER end;
	QueryPerformanceCounter(&end);

	pServerDE->DebugOut("Shortest Path Computed: %u ticks\r\n", (unsigned long)(end.QuadPart - start.QuadPart));
*/
	return DTRUE;
}