ai_shared.cpp

Blood 2全套源码

	pServerDE->SetObjectRotation(m_hObject, &rRot);	
    
    m_bTurnL = DTRUE;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	AI_Shared::FaceTarget()
//
//	PURPOSE:	Turn to face our target
//
// ----------------------------------------------------------------------- //
DBOOL AI_Shared::FaceTarget(HOBJECT m_hObject, HOBJECT m_hTarget)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE || !m_hObject || !m_hTarget) 
    {
        return DFALSE;
    }

	DVector vDir, vPos, vTargetPos;
	
	pServerDE->GetObjectPos(m_hObject, &vPos);
	pServerDE->GetObjectPos(m_hTarget, &vTargetPos);

	VEC_SUB(vDir, vTargetPos, vPos);
	VEC_NORM(vDir);

	DRotation rRot;
	ROT_INIT(rRot);
    
	pServerDE->GetObjectRotation(m_hObject, &rRot);

//	m_Angles.y = ATan2(vDir.x, vDir.z);
	DFLOAT fAmount = (DFLOAT) atan2(vDir.x, vDir.z);
    
	DVector vU, vR, vF;
	pServerDE->GetRotationVectors(&rRot, &vU, &vR, &vF);

	DFLOAT fAmount2 = (DFLOAT) atan2(vF.x, vF.z);
    
	pServerDE->EulerRotateY(&rRot, fAmount2 - fAmount);
	pServerDE->SetObjectRotation(m_hObject, &rRot);
    
    return DTRUE;
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	AI_Shared::CreateGibs(HOBJECT hObject)
//
//	PURPOSE:
//
// ----------------------------------------------------------------------- //

void AI_Shared::CreateGibs(HOBJECT hObject,DDWORD dwFlags,int nCorpse, int nNode)
{
	CServerDE* g_pServerDE = BaseClass::GetServerDE();

	DVector vPos, vVel, vParentDims, vRotationPeriods;

	HCLASS hClass = g_pServerDE->GetClass( "CGib" );
	if( !hClass )
		return;

	// Get dims of this gib...
	g_pServerDE->GetObjectPos( hObject, &vPos );
	g_pServerDE->GetObjectDims( hObject, &vParentDims );


	ObjectCreateStruct theStruct;
	INIT_OBJECTCREATESTRUCT(theStruct);

	theStruct.m_UserData = dwFlags;

	if(dwFlags & GIB_CORPSE)
	{
	    DRotation rRot;
		g_pServerDE->GetObjectRotation(hObject, &rRot);
			
		VEC_COPY(theStruct.m_Pos,vPos);
		ROT_COPY(theStruct.m_Rotation,rRot);

		g_pServerDE->GetModelFilenames(hObject,theStruct.m_Filename,MAX_CS_FILENAME_LEN+1,
											   theStruct.m_SkinName,MAX_CS_FILENAME_LEN+1);

		// Allocate an object...
		BaseClass* pObj = g_pServerDE->CreateObject( hClass, &theStruct );
		if( !pObj )
			return;

		g_pServerDE->SetModelAnimation(pObj->m_hObject,nCorpse);
       	g_pServerDE->SetModelLooping(pObj->m_hObject, DFALSE);

		DVector vDims;
		g_pServerDE->GetModelAnimUserDims(pObj->m_hObject, &vDims, g_pServerDE->GetModelAnimation(pObj->m_hObject));
		
		vPos.y -= (vParentDims.y - vDims.y) - 0.001f;
		
		g_pServerDE->SetObjectDims(pObj->m_hObject,&vDims);
		g_pServerDE->SetObjectPos(pObj->m_hObject,&vPos);

		//SCHLEGZ 3/10/98 2:07:28 AM: remove missing limbs from corpse
		DBOOL bStatus = DFALSE;
		DVector vBPos;

		vPos.y -= (vDims.y - 0.001f);	//Put the blood flush with the floor

		//HEAD/NECK
		g_pServerDE->GetModelNodeHideStatus(hObject,szNodes[NODE_NECK],&bStatus);
		if(bStatus)
		{
			HideLimb(pObj->m_hObject, NODE_NECK);
			g_pServerDE->GetModelNodeTransform(hObject,szNodes[NODE_NECK],&vBPos,&rRot);
			vBPos.y = vPos.y;
			CreateScorchMark(&vBPos, 20.0f, 60.0f, 3.0f, 30.0f, 0.0f, 60.0f, 255.0f, 0.0f, 0.0f); 
		}

		//RIGHT ARM
		g_pServerDE->GetModelNodeHideStatus(hObject,szNodes[NODE_RARM],&bStatus);
		if(bStatus)
		{
			HideLimb(pObj->m_hObject, NODE_RARM);
			g_pServerDE->GetModelNodeTransform(hObject,szNodes[NODE_RARM],&vBPos,&rRot);
			vBPos.y = vPos.y;
			CreateScorchMark(&vBPos, 20.0f, 60.0f, 3.0f, 30.0f, 0.0f, 60.0f, 255.0f, 0.0f, 0.0f); 
		}

		//LEFT ARM
		g_pServerDE->GetModelNodeHideStatus(hObject,szNodes[NODE_LARM],&bStatus);
		if(bStatus)	
		{
			HideLimb(pObj->m_hObject, NODE_LARM);
			g_pServerDE->GetModelNodeTransform(hObject,szNodes[NODE_LARM],&vBPos,&rRot);
			vBPos.y = vPos.y;
			CreateScorchMark(&vBPos, 20.0f, 60.0f, 3.0f, 30.0f, 0.0f, 60.0f, 255.0f, 0.0f, 0.0f); 
		}

		//LEFT LEG
		g_pServerDE->GetModelNodeHideStatus(hObject,szNodes[NODE_LLEG],&bStatus);
		if(bStatus)	
		{
			HideLimb(pObj->m_hObject, NODE_LLEG);
			g_pServerDE->GetModelNodeTransform(hObject,szNodes[NODE_LLEG],&vBPos,&rRot);
			vBPos.y = vPos.y;
			CreateScorchMark(&vBPos, 20.0f, 60.0f, 3.0f, 30.0f, 0.0f, 60.0f, 255.0f, 0.0f, 0.0f); 
		}

		//RIGHT LEG
		g_pServerDE->GetModelNodeHideStatus(hObject,szNodes[NODE_RLEG],&bStatus);
		if(bStatus)	
		{
			HideLimb(pObj->m_hObject, NODE_RLEG);
			g_pServerDE->GetModelNodeTransform(hObject,szNodes[NODE_RLEG],&vBPos,&rRot);
			vBPos.y = vPos.y;
			CreateScorchMark(&vBPos, 20.0f, 60.0f, 3.0f, 30.0f, 0.0f, 60.0f, 255.0f, 0.0f, 0.0f); 
		}

	}
	else
	{		
		int nNumDebris = (int)g_pServerDE->Random(3,8);

		// Make the gibs...
		for( int nItem = 0; nItem < nNumDebris; nItem++ )
		{		
			VEC_SET( theStruct.m_Pos, g_pServerDE->Random( -vParentDims.x, vParentDims.x ), 
									  g_pServerDE->Random( 0.1f, vParentDims.y ), 
									  g_pServerDE->Random( -vParentDims.z, vParentDims.z ));
			VEC_ADD( theStruct.m_Pos, theStruct.m_Pos, vPos );

			// Set the velocity using a vector from the center of the parent gib to the 
			// center of where the debris starts...
			VEC_COPY( vVel, theStruct.m_Pos );
			VEC_SUB( vVel, vVel, vPos );
			// Make sure the velocity is somewhat upward...
			vVel.y += vParentDims.y;
			if( VEC_MAGSQR( vVel ) > 0.01f )
			{
				VEC_NORM( vVel );
			}
			else
			{
				VEC_SET( vVel, 0.0f, 1.0f, 0.0f );
			}
			VEC_MULSCALAR( vVel, vVel, g_pServerDE->Random( 200.0f, 500.0f ));

			// Set the rotation periods around the x, y and z axes...
			VEC_SET( vRotationPeriods, g_pServerDE->Random( -1.0f, 1.0f ), 
									   g_pServerDE->Random( -1.0f, 1.0f ), 
									   g_pServerDE->Random( -1.0f, 1.0f ));

			//Copy the rotation vector
			VEC_COPY(theStruct.m_Rotation.m_Vec,vRotationPeriods);
				
			// Allocate an object...
			BaseClass* pObj = g_pServerDE->CreateObject( hClass, &theStruct );
			if( !pObj )
				break;

			//SCHLEGZ 3/11/98 7:27:09 PM: set the dims correctly
			DVector vDims;
			g_pServerDE->GetModelAnimUserDims(pObj->m_hObject, &vDims, g_pServerDE->GetModelAnimation(pObj->m_hObject));

			g_pServerDE->SetObjectDims(pObj->m_hObject,&vDims);
			g_pServerDE->SetVelocity( pObj->m_hObject, &vVel );
		}
	}

	return;
}


// ----------------------------------------------------------------------- //
// ROUTINE		: AI_Shared::CreateLimb
// DESCRIPTION	: 
// RETURN TYPE	: void 
// PARAMS		: HOBJECT hObject
// PARAMS		: DDWORD dwFlags
// PARAMS		: int nNode
// PARAMS		: DVector vDir
// ----------------------------------------------------------------------- //

void AI_Shared::CreateLimb(HOBJECT hObject, int nNode, DVector vDir)
{
	CServerDE* g_pServerDE = BaseClass::GetServerDE();

	DVector vPos, vVel, vParentDims;
	DRotation rRot;

	HCLASS hClass = g_pServerDE->GetClass( "CGib" );
	if( !hClass )
		return;

	// Get dims of this gib...
	g_pServerDE->GetObjectDims( hObject, &vParentDims );

	g_pServerDE->GetModelNodeTransform(hObject,szNodes[nNode],&vPos,&rRot);
	g_pServerDE->GetObjectRotation( hObject, &rRot );	//temp
	
	ObjectCreateStruct theStruct;
	INIT_OBJECTCREATESTRUCT(theStruct);

	switch(nNode)
	{
		case NODE_NECK:		theStruct.m_UserData = GIB_HEAD;	break;
		case NODE_RARM:		theStruct.m_UserData = GIB_ARM;		break;
		case NODE_LARM:		theStruct.m_UserData = GIB_ARM;		break;
		case NODE_LLEG:		theStruct.m_UserData = GIB_LEG;		break;
		case NODE_RLEG:		theStruct.m_UserData = GIB_LEG;		break;
		default:	return;
	}

	g_pServerDE->GetModelFilenames(hObject,theStruct.m_Filename,MAX_CS_FILENAME_LEN+1,
										   theStruct.m_SkinName,MAX_CS_FILENAME_LEN+1);

	VEC_COPY(theStruct.m_Pos,vPos);

	// Set the velocity using a vector from the center of the parent gib to the 
	// center of where the debris starts...
	VEC_COPY(vVel,vDir);

	// Make sure the velocity is somewhat upward...
/*	if( VEC_MAGSQR( vVel ) > 0.01f )
	{
		VEC_NORM( vVel );
	}
	else
	{
		VEC_SET( vVel, 0.0f, 1.0f, 0.0f );
	}
	*/
	vVel.y = 1.0f;
	VEC_NORM(vVel);
	VEC_MULSCALAR( vVel, vVel, g_pServerDE->Random( 200.0f, 500.0f ));

	//Copy the rotation vector
	ROT_COPY(theStruct.m_Rotation, rRot);
		
	// Allocate an object...
	CGib* pObj = (CGib*)g_pServerDE->CreateObject( hClass, &theStruct );
	if( !pObj )
		return;

	//Set the right animation
	if(nNode == NODE_NECK)
	{
		g_pServerDE->SetModelAnimation(pObj->m_hObject, g_pServerDE->GetAnimIndex(pObj->m_hObject,ANIM_LIMB_HEAD));
	}
	else if(nNode == NODE_RARM || nNode == NODE_LARM)
	{
		pObj->SetKickable(DFALSE);
		g_pServerDE->SetModelAnimation(pObj->m_hObject, g_pServerDE->GetAnimIndex(pObj->m_hObject,ANIM_LIMB_ARM));
	}
	else if(nNode == NODE_LLEG || nNode == NODE_RLEG)
	{
		pObj->SetKickable(DFALSE);
		g_pServerDE->SetModelAnimation(pObj->m_hObject, g_pServerDE->GetAnimIndex(pObj->m_hObject,ANIM_LIMB_LEG));
	}
	else 
		return;

    g_pServerDE->SetModelLooping(pObj->m_hObject, DFALSE);

	//hide the rest of the body
	DBOOL bStatus = DFALSE;

	for(int i = 0; i < NUM_ALL_NODES; i++)
	{
		if(nNode == NODE_NECK && i <= NODE_NECK)	i = NODE_NECK + 1;
		else if((nNode == NODE_RARM || nNode == NODE_LARM) && i == NODE_LARM)	i = NODE_LLEG - 1;
		else if((nNode == NODE_LLEG || nNode == NODE_RLEG) && i == NODE_LLEG) i = NODE_LLEG + 4;

		HideNodeAndSubNodes(pObj->m_hObject, i, !bStatus);		
	}

	//SCHLEGZ 3/11/98 7:27:09 PM: set the dims correctly
	DVector vDims;
	g_pServerDE->GetModelAnimUserDims(pObj->m_hObject, &vDims, g_pServerDE->GetModelAnimation(pObj->m_hObject));

	g_pServerDE->SetObjectDims(pObj->m_hObject,&vDims);

	//throw the limb out there
	g_pServerDE->SetVelocity( pObj->m_hObject, &vVel );

	return;
}

// ----------------------------------------------------------------------- //
// ROUTINE		: AI_Shared::HideLimb
// DESCRIPTION	: Hide a given node
// RETURN TYPE	: int 
// PARAMS		: HOBJECT hObject
// PARAMS		: int nNode
// PARAMS		: DBOOL bInverse = DFALSE
// ----------------------------------------------------------------------- //

DBOOL AI_Shared::HideLimb(HOBJECT hObject, int nNode, DBOOL bInverse)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();

	//is torso or pelvis?
	if(nNode == 2 || nNode == 3)
		return DFALSE;

	DBOOL bStatus = DFALSE;
	g_pServerDE->GetModelNodeHideStatus(hObject,szNodes[nNode],&bStatus);
	if(bStatus)
		return DFALSE;

	HideNodeAndSubNodes(hObject,nNode,DTRUE);		

	switch(nNode)
	{
		case NODE_NECK:			//NECK
		{	
			// Hide the head too
			HideNodeAndSubNodes(hObject,nNode-1,DTRUE);	
			break;
		}
		case NODE_RARM:			//RU_ARM
		{
			HideNodeAndSubNodes(hObject,nNode+1,DTRUE);	
			HideNodeAndSubNodes(hObject,nNode+2,DTRUE);
			HideNodeAndSubNodes(hObject,nNode+3,DTRUE);			
			break;
		}
		case NODE_LARM:			//LU_ARM	
		{
			HideNodeAndSubNodes(hObject,nNode+1,DTRUE);	
			HideNodeAndSubNodes(hObject,nNode+2,DTRUE);
			HideNodeAndSubNodes(hObject,nNode+3,DTRUE);						
			break;
		}
		case NODE_LLEG:			//LU_LEG
		{
			HideNodeAndSubNodes(hObject,nNode+1,DTRUE);
			HideNodeAndSubNodes(hObject,nNode+2,DTRUE);	
			HideNodeAndSubNodes(hObject,nNode+3,DTRUE);						
			break;
		}
		case NODE_RLEG:		//RU_LEG
		{
			HideNodeAndSubNodes(hObject,nNode+1,DTRUE);	
			HideNodeAndSubNodes(hObject,nNode+2,DTRUE);	
			HideNodeAndSubNodes(hObject,nNode+3,DTRUE);						
			break;
		}					
		default:	return DFALSE;
	}

	//inverse hide; hide the body and show the limb
	if(bInverse)
	{
		DBOOL bStatus = DFALSE;

		for(int i = 0; i < NUM_ALL_NODES; i++)
		{
			pServerDE->GetModelNodeHideStatus(hObject,szNodes[i],&bStatus);
			HideNodeAndSubNodes(hObject,i,!bStatus);	
		}
	}

	return DTRUE;
}

// ----------------------------------------------------------------------- //
// ROUTINE		: AI_Shared::HideNodeAndSubNodes
// DESCRIPTION	: Hides a node and any sub nodes ( with _extra# extension)
// RETURN TYPE	: BOOL 
// PARAMS		: HOBJECT hObject
// PARAMS		: int nNode
// PARAMS		: DBOOL bInverse = DFALSE
// ----------------------------------------------------------------------- //

DBOOL AI_Shared::HideNodeAndSubNodes(HOBJECT hObject, int nNode, DBOOL bHide)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();

	if (!pServerDE || !hObject || nNode >= NUM_ALL_NODES) return DFALSE;

	// Hide the base node
	pServerDE->SetModelNodeHideStatus(hObject, szNodes[nNode], bHide);
	int i=1;
	char szNodeName[100];
	sprintf(szNodeName, "%s_extra%d", szNodes[nNode], i);

	// Loop until all nodes are hidden
	while (pServerDE->SetModelNodeHideStatus(hObject, szNodeName, bHide) == DE_OK)
	{
		i++;
		sprintf(szNodeName, "%s_extra%d", szNodes[nNode], i);
	}
	return DTRUE;
}
	

// ----------------------------------------------------------------------- //
// ROUTINE		: AI_Shared::HideLimb
// DESCRIPTION	: Resets all nodes to not hidden.
// RETURN TYPE	: void
// PARAMS		: HOBJECT hObject
// ----------------------------------------------------------------------- //