ai_shared.cpp

Blood 2全套源码

	DVector vTargetPos, vPos;
    // Our current position	
	pServerDE->GetObjectPos(m_hObject, &vPos);
	pServerDE->GetObjectPos(hPTarget, &vTargetPos);
    
    // Change to the PTargets Eye level
    DVector vDims;
	pServerDE->GetObjectDims(hPTarget, &vDims);
	vTargetPos.y += vDims.y / 2.0f;
//	vTargetPos.y -= m_fEyeLevelOffset;
	vTargetPos.y -= 1;

    // Get the distance from the target
    DFLOAT ydist = vTargetPos.y - vPos.y;
    DFLOAT zdist = vTargetPos.z - vPos.z;
    
    // always want positive distance.
    if (zdist < 0)  zdist = zdist * -1;
    
    DFLOAT fPitch   = (DFLOAT) atan2(ydist,zdist);
    
//    char buf[128];
//    sprintf(buf, "vPos %f  %f %f ", vPos.x, vPos.y, vPos.z);
//    BPrint(buf);
//    sprintf(buf, "vTarget %f  %f %f ", vTargetPos.x, vTargetPos.y, vTargetPos.z);
//    BPrint(buf);
//    sprintf(buf, "Pitch %f  %f %f ", fPitch, ydist, zdist);
//    BPrint(buf);
    
    return fPitch;
}




// ----------------------------------------------------------------------- //
//
//	ROUTINE:	AI_Shared::
//
//	PURPOSE:	
//
// ----------------------------------------------------------------------- //
void AI_Shared::Strafe(HOBJECT m_hObject, DFLOAT m_strafeSpeed)
{
    
    DFLOAT m_strafe_dist;
	DVector vAccel;
   	DVector vPos;

	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE || !m_hObject ) return;
    
	// Zero our acceleration
	VEC_INIT(vAccel);
    
	DRotation rRot;
    DVector m_vUp, m_vRight, m_vForward;
    
	VEC_INIT(m_vUp);
	VEC_INIT(m_vRight);
	VEC_INIT(m_vForward);

	pServerDE->GetObjectRotation(m_hObject, &rRot);
	pServerDE->GetRotationVectors(&rRot, &m_vUp, &m_vRight, &m_vForward);
    
    // check for jump completed
    if (m_bStrafing == DTRUE)
    {
    
// Check if we have reached the new location yet...
// Also check for ledge and walls...    

	    pServerDE->GetObjectPos(m_hObject, &vPos);
		m_strafe_dist = VEC_DIST(vPos, m_vLastStrafePos);
        
        if ( m_strafe_dist > 50.0f )
        {
    		VEC_ADD(vAccel, vAccel, m_vForward);
		    VEC_MULSCALAR(m_vRight, m_vRight, 0)
	    	VEC_ADD(vAccel, vAccel, m_vRight)

    		pServerDE->SetAcceleration(m_hObject, &vAccel);
//            NewSubState(m_newstate);
            m_bStrafing = DFALSE;
            
            // Cycle to the next metacommand
//        	m_bRecompute = DTRUE;
            
        }
        
    }
    else
    {
        // Save position 
        // check new position and distance from saved position
        // if => distance then stop strafing
	    pServerDE->GetObjectPos(m_hObject, &m_vLastStrafePos);
        
		VEC_ADD(vAccel, vAccel, m_vForward);
		VEC_MULSCALAR(m_vRight, m_vRight, m_strafeSpeed)
		VEC_ADD(vAccel, vAccel, m_vRight)

    //	pServerDE->PlaySound(m_hObject,"Sounds\\jump.wav", 400, 0,0,0 );
		pServerDE->SetAcceleration(m_hObject, &vAccel);
        m_bStrafing = DTRUE;
    }
        
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	AI_Shared::
//
//	PURPOSE:	
//
// ----------------------------------------------------------------------- //
DBOOL AI_Shared::Jump(HOBJECT m_hObject, DFLOAT m_YjumpSpeed, DFLOAT m_ZjumpSpeed)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE || !m_hObject ) return DFALSE;

	DVector vPos;
	DRotation rRot;
    DVector m_vUp, m_vRight, m_vForward;
    
	VEC_INIT(m_vUp);
	VEC_INIT(m_vRight);
	VEC_INIT(m_vForward);

	pServerDE->GetObjectRotation(m_hObject, &rRot);
	pServerDE->GetRotationVectors(&rRot, &m_vUp, &m_vRight, &m_vForward);
    
    // check for jump completed
    if (m_bJumping == DTRUE)
    {
    
	    CollisionInfo collisionInfo;
    	DBOOL bIsStandingOn;

	    pServerDE->GetStandingOn(m_hObject, &collisionInfo);
    	bIsStandingOn = (collisionInfo.m_hObject == pServerDE->GetWorldObject());
    
        if ( bIsStandingOn == DTRUE )
        {
            // Do not change until I hit the ground...
            // return to this substate
    		m_bJumping = DFALSE;
        }
        
    }
    else
    {
    
//	    DVector vTemp;
    	pServerDE->GetObjectPos(m_hObject, &vPos);

//    	VEC_MULSCALAR(vTemp, m_vForward, 1.0f);
//	    VEC_ADD(vPos, vPos, vTemp);
        
        // change the y velocity!
        vPos.y = m_vForward.y + m_YjumpSpeed;
        vPos.x = m_vForward.x;
        vPos.z = m_vForward.z;
        
    //	pServerDE->MoveObject(m_hObject, &vPos);
		PlaySoundFromObject(m_hObject, "Sounds\\jump.wav", 400, SOUNDPRIORITY_AI_MEDIUM);
	    pServerDE->SetVelocity (m_hObject, &vPos);
    
//    	DVector vGVec,vGAcc;
//	    pServerDE->GetVelocity (m_hObject, &vGVec);
//        char buf[128];
//        sprintf(buf, "GetVec %f %f %f", vGVec.x, vGVec.y, vGVec.z );
//        BPrint(buf);
        
		m_bJumping = DTRUE;
    }
    
    return m_bJumping;
        
}



// MoveForward

// MoveBackward
int AI_Shared::MoveBackward(HOBJECT m_hObject, DFLOAT m_fSpeed, int m_theAnima)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE || !m_hObject ) return 0;

// get rotation
	DRotation rRot;
    DVector m_vUp, m_vRight, m_vForward;
    
	VEC_INIT(m_vUp);
	VEC_INIT(m_vRight);
	VEC_INIT(m_vForward);

	pServerDE->GetObjectRotation(m_hObject, &rRot);
	pServerDE->GetRotationVectors(&rRot, &m_vUp, &m_vRight, &m_vForward);

	DVector vPos, vTemp, vLastPos, vDir;
    
	VEC_COPY(vDir, m_vForward);
	VEC_MULSCALAR(vDir, vDir, -1.0f); // Backward
    
	pServerDE->GetObjectPos(m_hObject, &vPos);

    // Save the current position as the Last Position...
	VEC_COPY(vLastPos, vPos);

	VEC_MULSCALAR(vTemp, vDir, m_fSpeed);
    
	VEC_ADD(vPos, vPos, vTemp);
	pServerDE->MoveObject(m_hObject, &vPos);

    m_bTurnR = DFALSE;
    m_bTurnL = DFALSE;
    return 0;
}





// ----------------------------------------------------------------------- //
//
//	ROUTINE:	AI_Shared::WalkThisWay
//
//	PURPOSE:	
//
// ----------------------------------------------------------------------- //
// return 0 if now walls, etc...
// return 1 if found a wall
// return 2 if found a ledge
// return 3 if stuck on something
// 
int AI_Shared::WalkThisWay(HOBJECT m_hObject, DFLOAT m_fSpeed, int m_theAnima)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE || !m_hObject ) return 0;

// get rotation
	DRotation rRot;
    DVector m_vUp, m_vRight, m_vForward, vDims, m_vLeft;
    
	VEC_INIT(m_vUp);
	VEC_INIT(m_vRight);
	VEC_INIT(m_vForward);

	pServerDE->GetObjectRotation(m_hObject, &rRot);
	pServerDE->GetRotationVectors(&rRot, &m_vUp, &m_vRight, &m_vForward);


//    // Only set the looping animation if it has not been set Yet!
//    if (m_nCurAnimation != m_theAnima)
//    {
//    	SetAnimation(m_hObject, m_theAnima);
//    }
    
    // 1st check for walls/objects in front
	pServerDE->GetModelAnimUserDims(m_hObject, &vDims, pServerDE->GetModelAnimation(m_hObject));

//	pServerDE->GetObjectDims(m_hObject,&vDims);
	VEC_MULSCALAR(m_vLeft,m_vRight,-1);

	if(DistToWorld(m_hObject, m_vForward) - vDims.z < m_fSpeed + vDims.z ||
	   DistToWorld(m_hObject, m_vRight) - vDims.x < m_fSpeed + vDims.x ||
	   DistToWorld(m_hObject, m_vLeft) - vDims.x < m_fSpeed + vDims.x)
//	if(DistToWorldForward() < m_fSpeed) 
	{
        // Random, but if we where turning last time, them turn the same way!
//        TurnRorL(m_hObject);
		return 1;
	}

    // can only check for ledges if we have enough room to put a point in front!
    // if No walls then lets check for ledges
    if( IsLedge(m_hObject, m_fSpeed * 2.5f) )
    {
//        TurnL(m_hObject);
//        if ( IsLedge(m_hObject, m_fSpeed * 2.5f) )
//        {
//            TurnL(m_hObject);
//        }
//		return 2;
    }

//	m_bTurn = DFALSE;

//	DRotation rRot;
//	pServerDE->GetObjectRotation(m_hObject, &rRot);
//	pServerDE->GetRotationVectors(&rRot, &m_vUp, &m_vRight, &m_vForward);

	DVector vPos, vTemp, vLastPos;
	pServerDE->GetObjectPos(m_hObject, &vPos);

    // Save the current position as the Last Position...
	VEC_COPY(vLastPos, vPos);

	VEC_MULSCALAR(vTemp, m_vForward, m_fSpeed);
	VEC_ADD(vPos, vPos, vTemp);
	pServerDE->MoveObject(m_hObject, &vPos);


    // Check to see if we are stuck...
	if ( StuckOnSomething(m_hObject, m_fSpeed, vLastPos) )
	{
		// Random, but if we where turning last time, them turn the same way!
//        TurnRorL(m_hObject);
		return 3;
	}

    m_bTurnR = DFALSE;
    m_bTurnL = DFALSE;
    return 0;
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	AI_Shared::StuckOnSomething
//
//	PURPOSE:	Check to see if we've moved at all
//
// ----------------------------------------------------------------------- //

DBOOL AI_Shared::StuckOnSomething(HOBJECT m_hObject, DFLOAT m_fSpeed, DVector m_vLastPos)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
    if (!pServerDE || !m_hObject ) return DFALSE;

	DVector vPos, vTemp;
    
	pServerDE->GetObjectPos(m_hObject, &vPos);
	VEC_SUB(vTemp, m_vLastPos, vPos);

	DFLOAT fDist = VEC_MAGSQR(vTemp);

	if (fDist < m_fSpeed /*|| DistToWorldForward(m_hObject) < 100*/)	//SCHLEGZ: didn't make any sense hence removed
	{
		return DTRUE;
	}

	return DFALSE;
}


void AI_Shared::Roll(HOBJECT m_hObject, DVector vDir, DFLOAT fSpeed)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
    if (!pServerDE || !m_hObject ) return;

	DVector vPos, vTemp, vLastPos;
	pServerDE->GetObjectPos(m_hObject, &vPos);

    // Save the current position as the Last Position...
	VEC_COPY(vLastPos, vPos);

	VEC_MULSCALAR(vTemp, vDir, fSpeed);
	VEC_ADD(vPos, vPos, vTemp);
	pServerDE->MoveObject(m_hObject, &vPos);

	return;
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	AI_Shared::
//
//	PURPOSE:	
//
// ----------------------------------------------------------------------- //
void AI_Shared::TurnRorL(HOBJECT m_hObject, DFLOAT m_fRadius)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE || !m_hObject ) return;
    
	// Pick a direction to turn
	// Rotate one direction some amount
    if (m_bTurnR)
	{
	    TurnR(m_hObject, m_fRadius);
	}
	else if (m_bTurnL)
	{
        TurnL(m_hObject, m_fRadius);
	}
    else if( (pServerDE->IntRandom(1, 2) == 1) )
	{
	    TurnR(m_hObject, m_fRadius);
	}
	else
	{
        TurnL(m_hObject, m_fRadius);
	}
}



// ----------------------------------------------------------------------- //
//
//	ROUTINE:	AI_Shared::
//
//	PURPOSE:	
//
// ----------------------------------------------------------------------- //
void AI_Shared::TurnR(HOBJECT m_hObject, DFLOAT m_fRadius)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE || !m_hObject ) return;

//	DFLOAT m_fTurn = -0.35f;  // Right
    DFLOAT m_fTurn = m_fRadius * -1;

    DRotation rRot;
	pServerDE->GetObjectRotation(m_hObject, &rRot);
    pServerDE->EulerRotateY(&rRot, m_fTurn);
	pServerDE->SetObjectRotation(m_hObject, &rRot);	
    
    m_bTurnR = DTRUE;
}



// ----------------------------------------------------------------------- //
//
//	ROUTINE:	AI_Shared::
//
//	PURPOSE:	
//
// ----------------------------------------------------------------------- //
void AI_Shared::TurnL(HOBJECT m_hObject, DFLOAT m_fRadius)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE || !m_hObject ) return;

//	DFLOAT m_fTurn = 0.35f;  // Left
    DFLOAT m_fTurn = m_fRadius;
    
    DRotation rRot;
	pServerDE->GetObjectRotation(m_hObject, &rRot);
    pServerDE->EulerRotateY(&rRot, m_fTurn);