source-engine/game/server/episodic/ai_behavior_alyx_injured.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: FIXME: This will ultimately become a more generic implementation
//
//=============================================================================

#include "cbase.h"
#include "ai_memory.h"
#include "ai_speech.h"
#include "ai_behavior.h"
#include "ai_navigator.h"
#include "ai_playerally.h"
#include "ai_behavior_follow.h"
#include "ai_moveprobe.h"

#include "ai_behavior_alyx_injured.h"

ConVar g_debug_injured_follow( "g_debug_injured_follow", "0" );
ConVar injured_help_plee_range( "injured_help_plee_range", "256" );

#define	TLK_INJURED_FOLLOW_TOO_FAR	"TLK_INJURED_FOLLOW_TOO_FAR"

BEGIN_DATADESC( CAI_BehaviorAlyxInjured )
	DEFINE_FIELD( m_flNextWarnTime,	FIELD_TIME ),
	// m_ActivityMap

END_DATADESC();

Activity	ACT_INJURED_COWER;
Activity	ACT_GESTURE_INJURED_COWER_FLINCH;

#define	COVER_DISTANCE	128.0f			// Distance behind target to find cover
#define	MIN_ENEMY_MOB	3				// Number of enemies considerd overwhelming
#define	MAX_DIST_FROM_FOLLOW_TARGET	256	// If the follow target is farther than this, the NPC will run to it

//=============================================================================

CAI_BehaviorAlyxInjured::CAI_BehaviorAlyxInjured( void ) : m_flNextWarnTime( 0.0f )
{
	SetDefLessFunc( m_ActivityMap );
}

struct ActivityMap_t
{
	Activity		activity;
	Activity		translation;
};

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CAI_BehaviorAlyxInjured::PopulateActivityMap( void )
{
	// Maps one activity to a translated one
	ActivityMap_t map[] =
	{
		// Runs
		{ ACT_RUN,					ACT_RUN_HURT },
		{ ACT_RUN_AIM,				ACT_RUN_AIM },	// FIMXE: No appropriate temp anim right now!
		{ ACT_RUN_CROUCH,			ACT_RUN_HURT },
		{ ACT_RUN_CROUCH_AIM,		ACT_RUN_HURT },
		{ ACT_RUN_PROTECTED,		ACT_RUN_HURT },
		{ ACT_RUN_RELAXED,			ACT_RUN_HURT },
		{ ACT_RUN_STIMULATED,		ACT_RUN_HURT },
		{ ACT_RUN_AGITATED,			ACT_RUN_HURT },
		{ ACT_RUN_AIM_RELAXED,		ACT_RUN_AIM_RELAXED },		// FIMXE: No appropriate temp anim right now!
		{ ACT_RUN_AIM_STIMULATED,	ACT_RUN_AIM_STIMULATED },	// FIMXE: No appropriate temp anim right now!
		{ ACT_RUN_AIM_AGITATED,		ACT_RUN_AIM_AGITATED },		// FIMXE: No appropriate temp anim right now!
		{ ACT_RUN_HURT,				ACT_RUN_HURT },
		
		// Walks
		{ ACT_WALK,					ACT_WALK_HURT },
		{ ACT_WALK_AIM,				ACT_WALK_HURT },
		{ ACT_WALK_CROUCH,			ACT_WALK_HURT },
		{ ACT_WALK_CROUCH_AIM,		ACT_WALK_HURT },
		{ ACT_WALK_RELAXED,			ACT_WALK_HURT },
		{ ACT_WALK_STIMULATED,		ACT_WALK_HURT },
		{ ACT_WALK_AGITATED,		ACT_WALK_HURT },
		{ ACT_WALK_AIM_RELAXED,		ACT_WALK_HURT },
		{ ACT_WALK_AIM_STIMULATED,	ACT_WALK_HURT },
		{ ACT_WALK_AIM_AGITATED,	ACT_WALK_HURT },
		{ ACT_WALK_HURT,			ACT_WALK_HURT },

		{ ACT_IDLE,					ACT_IDLE_HURT },
		{ ACT_COVER_LOW,			ACT_INJURED_COWER },
		{ ACT_COWER,				ACT_INJURED_COWER },
	};

	// Clear the map
	m_ActivityMap.RemoveAll();

	// Add all translations
	for ( int i = 0; i < ARRAYSIZE( map ); i++ )
	{
		Assert( m_ActivityMap.Find( map[i].activity ) == m_ActivityMap.InvalidIndex() );
		m_ActivityMap.Insert( map[i].activity, map[i].translation );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Populate the list after save/load
//-----------------------------------------------------------------------------
void CAI_BehaviorAlyxInjured::OnRestore( void )
{
	PopulateActivityMap();
}

//-----------------------------------------------------------------------------
// Purpose: Populate the list on spawn
//-----------------------------------------------------------------------------
void CAI_BehaviorAlyxInjured::Spawn( void )
{
	PopulateActivityMap();
}

//-----------------------------------------------------------------------------
// Purpose: Get the flinch activity for us to play
// Input  : bHeavyDamage - 
//			bGesture - 
// Output : Activity
//-----------------------------------------------------------------------------
Activity CAI_BehaviorAlyxInjured::GetFlinchActivity( bool bHeavyDamage, bool bGesture )
{
	// 
	if ( ( bGesture == false ) || ( GetOuter()->GetActivity() != ACT_COWER ) )
		return BaseClass::GetFlinchActivity( bHeavyDamage, bGesture );

	// Translate the flinch if we're cowering
	return ACT_GESTURE_INJURED_COWER_FLINCH;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : nActivity - 
//-----------------------------------------------------------------------------
Activity CAI_BehaviorAlyxInjured::NPC_TranslateActivity( Activity nActivity )
{
	// Find out what the base class wants to do with the activity
	Activity nNewActivity = BaseClass::NPC_TranslateActivity( nActivity );

	// Look it up in the translation map
	int nIndex = m_ActivityMap.Find( nNewActivity );
	
	if ( m_ActivityMap.IsValidIndex( nIndex ) )
		return m_ActivityMap[nIndex];

	return nNewActivity;
}

//-----------------------------------------------------------------------------
// Purpose: Determines if Alyx should run away from enemies or stay put
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAI_BehaviorAlyxInjured::ShouldRunToCover( void )
{
	Vector	vecRetreatPos;
	float	flRetreatRadius = 128.0f;
	
	// See how far off from our cover position we are
	if ( FindCoverFromEnemyBehindTarget( GetFollowTarget(), flRetreatRadius, &vecRetreatPos ) )
	{
		float flDestDistSqr = ( GetOuter()->WorldSpaceCenter() - vecRetreatPos ).LengthSqr();
		if ( flDestDistSqr > Square( flRetreatRadius ) )
			return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: See if we need to follow our goal
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAI_BehaviorAlyxInjured::ShouldRunToFollowGoal( void )
{
	// If we're too far from our follow target, we need to chase after them
	float flDistToFollowGoalSqr = ( GetOuter()->GetAbsOrigin() - GetFollowTarget()->GetAbsOrigin() ).LengthSqr();
	if ( flDistToFollowGoalSqr > Square(MAX_DIST_FROM_FOLLOW_TARGET) )
		return true;

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: Translate base schedules into overridden forms
//-----------------------------------------------------------------------------
int CAI_BehaviorAlyxInjured::TranslateSchedule( int scheduleType )
{
	switch( scheduleType )
	{
	case SCHED_RUN_FROM_ENEMY:
	case SCHED_RUN_FROM_ENEMY_MOB:
		{
			// Get under cover if we're able to
			if ( ShouldRunToCover() )
				return SCHED_INJURED_RUN_FROM_ENEMY;

			// Run to our follow goal if we're too far away from it
			if ( ShouldRunToFollowGoal() )
				return SCHED_FOLLOW;

			// Cower if surrounded
			if ( HasCondition( COND_INJURED_OVERWHELMED ) )
				return SCHED_INJURED_COWER;

			// Face our enemies
			return SCHED_INJURED_FEAR_FACE;
		}
		break;

	case SCHED_RUN_FROM_ENEMY_FALLBACK:
		return SCHED_INJURED_COWER;
		break;
	}

	return BaseClass::TranslateSchedule( scheduleType );
}

//-----------------------------------------------------------------------------
// Purpose: Pick up failure cases and handle them
//-----------------------------------------------------------------------------
int CAI_BehaviorAlyxInjured::SelectFailSchedule( int failedSchedule, int failedTask, AI_TaskFailureCode_t taskFailCode )
{
	// Failed schedules
	switch( failedSchedule )
	{
	case SCHED_RUN_FROM_ENEMY:
	case SCHED_RUN_FROM_ENEMY_MOB:
	case SCHED_FOLLOW:
		return SCHED_INJURED_COWER;
	}

	// Failed tasks
	switch( failedTask )
	{
	case TASK_FIND_COVER_FROM_ENEMY:
	case TASK_FIND_INJURED_COVER_FROM_ENEMY:
		
		// Only cower if we're already near enough to our follow target
		float flDistToFollowTargetSqr = ( GetOuter()->GetAbsOrigin() - GetFollowTarget()->GetAbsOrigin() ).LengthSqr();
		if (  flDistToFollowTargetSqr > Square( 256 ) )
			return SCHED_FOLLOW;

		return SCHED_INJURED_COWER;
		break;
	}

	return BaseClass::SelectFailSchedule( failedSchedule, failedTask, taskFailCode );
}

//-----------------------------------------------------------------------------
// Purpose: Find the general direction enemies are coming towards us at
//-----------------------------------------------------------------------------
bool CAI_BehaviorAlyxInjured::FindThreatDirection2D( const Vector &vecSource, Vector *vecOut )
{
	// Find the general direction our threat is coming from
	bool bValid = false;
	Vector vecScratch;
	AIEnemiesIter_t	iter;

	// Iterate through all known enemies
	for( AI_EnemyInfo_t *pMemory = GetOuter()->GetEnemies()->GetFirst(&iter); pMemory != NULL; pMemory = GetOuter()->GetEnemies()->GetNext(&iter) )
	{
		if ( pMemory == NULL || pMemory->hEnemy == NULL )
			continue;

		vecScratch = ( vecSource - pMemory->hEnemy->WorldSpaceCenter() );
		VectorNormalize( vecScratch	);
		
		(*vecOut) += vecScratch;
		bValid = true;
	}

	// Find the general direction
	(*vecOut).z = 0.0f;
	VectorNormalize( (*vecOut) );
	return bValid;
}

//-----------------------------------------------------------------------------
// Purpose: Find a position that hides us from our threats while interposing the
//			target entity between us and the threat
// Input  : pTarget - entity to hide behind
//			flRadius - Radius around the target to search
//			*vecOut - position
//-----------------------------------------------------------------------------
bool CAI_BehaviorAlyxInjured::FindCoverFromEnemyBehindTarget( CBaseEntity *pTarget, float flRadius, Vector *vecOut )
{
	if ( pTarget == NULL )
		return false;

	Vector	vecTargetPos = pTarget->GetAbsOrigin();
	Vector	vecThreatDir = vec3_origin;
	
	// Find our threat direction and base our cover on that
	if ( FindThreatDirection2D( vecTargetPos, &vecThreatDir ) )
	{
		// Get a general location for taking cover
		Vector vecTestPos = vecTargetPos + ( vecThreatDir * flRadius );

		if ( g_debug_injured_follow.GetBool() )
		{
			NDebugOverlay::HorzArrow( GetOuter()->GetAbsOrigin(), vecTestPos, 8.0f, 255, 255, 0, 32, true, 2.0f );
		}

		// Make sure we never move towards our threat to get to cover!
		Vector vecMoveDir = GetOuter()->GetAbsOrigin() - vecTestPos;
		VectorNormalize( vecMoveDir );
		float flDotToCover = DotProduct( vecMoveDir, vecThreatDir );
		if ( flDotToCover > 0.0f )
		{
			if ( g_debug_injured_follow.GetBool() )
			{
				NDebugOverlay::HorzArrow( GetOuter()->GetAbsOrigin(), vecTestPos, 8.0f, 255, 0, 0, 32, true, 2.0f );
			}

			return false;
		}

		AIMoveTrace_t moveTrace;
		GetOuter()->GetMoveProbe()->MoveLimit(	NAV_GROUND, 
			GetOuter()->GetAbsOrigin(), 
			vecTestPos, 
			MASK_SOLID_BRUSHONLY, 
			NULL, 
			0, 
			&moveTrace );

		bool bWithinRangeToGoal = ( moveTrace.vEndPosition - vecTestPos ).Length2DSqr() < Square( GetOuter()->GetHullWidth() * 3.0f );
		bool bCanStandAtGoal = GetOuter()->GetMoveProbe()->CheckStandPosition( moveTrace.vEndPosition, MASK_SOLID_BRUSHONLY );

		if ( bWithinRangeToGoal == false || bCanStandAtGoal == false )
		{
			if ( g_debug_injured_follow.GetBool() )
			{
				NDebugOverlay::SweptBox( GetOuter()->GetAbsOrigin(), vecTestPos, GetOuter()->GetHullMins(), GetOuter()->GetHullMaxs(), vec3_angle, 255, 0, 0, 0, 2.0f );
			}

			return false;
		}

		// Accept it
		*vecOut =  moveTrace.vEndPosition;

		if ( g_debug_injured_follow.GetBool() )
		{
			NDebugOverlay::SweptBox( GetOuter()->GetAbsOrigin(),  (*vecOut), GetOuter()->GetHullMins(), GetOuter()->GetHullMaxs(), vec3_angle, 0, 255, 0, 0, 2.0f );
		}

		return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pTask - 
//-----------------------------------------------------------------------------
void CAI_BehaviorAlyxInjured::StartTask( const Task_t *pTask )
{
	switch( pTask->iTask )
	{
	case TASK_FIND_COVER_FROM_ENEMY:
		{
			CBaseEntity *pLeader = GetFollowTarget();
			if ( !pLeader )
			{
				BaseClass::StartTask( pTask );
				break;
			}

			// Find a position behind our follow target
			Vector coverPos = vec3_invalid;
			if ( FindCoverFromEnemyBehindTarget( pLeader, COVER_DISTANCE, &coverPos ) )
			{
				AI_NavGoal_t goal( GOALTYPE_LOCATION, coverPos, ACT_RUN, AIN_HULL_TOLERANCE, AIN_DEF_FLAGS );
				GetOuter()->GetNavigator()->SetGoal( goal );		
				GetOuter()->m_flMoveWaitFinished = gpGlobals->curtime + pTask->flTaskData;
				TaskComplete();
				return;
			}

			// Couldn't find anything
			TaskFail( FAIL_NO_COVER );
			break;
		}

	default:
		BaseClass::StartTask( pTask );
		break;
	}
}

//-----------------------------------------------------------------------------
// Purpose: Whether or not Alyx is injured
//-----------------------------------------------------------------------------
bool CAI_BehaviorAlyxInjured::IsInjured( void ) const 
{ 
	return IsAlyxInInjuredMode();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CAI_BehaviorAlyxInjured::GatherConditions( void )
{
	BaseClass::GatherConditions();

	// Always stomp over this
	ClearCondition( COND_INJURED_TOO_FAR_FROM_PLAYER );
	ClearCondition( COND_INJURED_OVERWHELMED );

	// See if we're overwhelmed by foes
	if ( NumKnownEnemiesInRadius( GetOuter()->GetAbsOrigin(), COVER_DISTANCE ) >= MIN_ENEMY_MOB )
	{
		SetCondition( COND_INJURED_OVERWHELMED );
	}

	// Determines whether we consider ourselves in danger
	bool bInDanger = (  HasCondition( COND_LIGHT_DAMAGE ) || 
						HasCondition( COND_HEAVY_DAMAGE ) || 
						HasCondition( COND_INJURED_OVERWHELMED ) );

	// See if we're too far away from the player and in danger
	if ( AI_IsSinglePlayer() && bInDanger )
	{
		bool bWarnPlayer = false;

		// This only works in single-player
		CBasePlayer *pPlayer = UTIL_PlayerByIndex( 1 );
		if ( pPlayer != NULL )
		{
			// FIXME: This distance may need to be the length of the shortest walked path between the follower and the target

			// Get our approximate distance to the player
			float flDistToPlayer = UTIL_DistApprox2D( GetOuter()->GetAbsOrigin(), pPlayer->GetAbsOrigin() );
			if ( flDistToPlayer > injured_help_plee_range.GetFloat() )
			{
				bWarnPlayer = true;
			}
			else if ( flDistToPlayer > (injured_help_plee_range.GetFloat()*0.5f) && HasCondition( COND_SEE_PLAYER ) == false )
			{
				// Cut our distance in half if we can't see the player
				bWarnPlayer = true;
			}
		}

		// Yell for help!
		if ( bWarnPlayer )
		{
			// FIXME: This should be routed through the normal speaking code with a system to emit from the player's suit.
			
			CBasePlayer *pPlayer = UTIL_PlayerByIndex( 1 );
			//float flPlayerDistSqr = ( GetOuter()->GetAbsOrigin() - pPlayer->GetAbsOrigin() ).LengthSqr();

			// If the player is too far away or we can't see him
			//if ( HasCondition( COND_SEE_PLAYER ) == false || flPlayerDistSqr > Square( 128 ) )
			{
				if ( m_flNextWarnTime < gpGlobals->curtime )
				{
					pPlayer->EmitSound( "npc_alyx.injured_too_far" );
					m_flNextWarnTime = gpGlobals->curtime + random->RandomFloat( 3.0f, 5.0f );
				}
			}
			/*
			else
			{
				SpeakIfAllowed( TLK_INJURED_FOLLOW_TOO_FAR );
				m_flNextWarnTime = gpGlobals->curtime + random->RandomFloat( 3.0f, 5.0f );
			}
			*/

			SetCondition( COND_INJURED_TOO_FAR_FROM_PLAYER );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Speak a concept if we're able to
//-----------------------------------------------------------------------------
void CAI_BehaviorAlyxInjured::SpeakIfAllowed( AIConcept_t concept )
{
	CAI_Expresser *pExpresser = GetOuter()->GetExpresser();
	if ( pExpresser == NULL )
		return;

	// Must be able to speak the concept
	if ( pExpresser->CanSpeakConcept( concept ) )
	{
		pExpresser->Speak( concept );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Get the number of known enemies within a radius to a point
//-----------------------------------------------------------------------------
int CAI_BehaviorAlyxInjured::NumKnownEnemiesInRadius( const Vector &vecSource, float flRadius )
{
	int	nNumEnemies = 0;
	float flRadiusSqr = Square( flRadius );

	AIEnemiesIter_t	iter;

	// Iterate through all known enemies
	for( AI_EnemyInfo_t *pMemory = GetEnemies()->GetFirst(&iter); pMemory != NULL; pMemory = GetEnemies()->GetNext(&iter) )
	{
		if ( pMemory == NULL || pMemory->hEnemy == NULL )
			continue;

		// Must hate or fear them
		if ( GetOuter()->IRelationType( pMemory->hEnemy ) != D_HT && GetOuter()->IRelationType( pMemory->hEnemy ) != D_FR )
			continue;

		// Count only the enemies I've seen recently
		if ( gpGlobals->curtime - pMemory->timeLastSeen > 0.5f )
			continue;

		// Must be within the radius we've specified
		float flEnemyDistSqr = ( vecSource - pMemory->hEnemy->GetAbsOrigin() ).Length2DSqr();
		if ( flEnemyDistSqr < flRadiusSqr )
		{
			nNumEnemies++;
		}
	}

	return nNumEnemies;
}

// ----------------------------------------------
// Custom AI declarations
// ----------------------------------------------

AI_BEGIN_CUSTOM_SCHEDULE_PROVIDER( CAI_BehaviorAlyxInjured )
{
	DECLARE_ACTIVITY( ACT_GESTURE_INJURED_COWER_FLINCH )
	DECLARE_ACTIVITY( ACT_INJURED_COWER )

	DECLARE_CONDITION( COND_INJURED_TOO_FAR_FROM_PLAYER )
	DECLARE_CONDITION( COND_INJURED_OVERWHELMED )

	DECLARE_TASK( TASK_FIND_INJURED_COVER_FROM_ENEMY )

	DEFINE_SCHEDULE
	(
		SCHED_INJURED_COWER,

		"	Tasks"
		// TOOD: Announce cower
		"		TASK_PLAY_SEQUENCE	ACTIVITY:ACT_COWER"
		"		TASK_WAIT			2"
		""
		"	Interrupts"
		"		COND_GIVE_WAY"
		"		COND_PLAYER_PUSHING"
	)

	DEFINE_SCHEDULE
	(
		SCHED_INJURED_FEAR_FACE,

		"	Tasks"
		"		 TASK_STOP_MOVING			0"
		"		 TASK_SET_ACTIVITY			ACTIVITY:ACT_IDLE" // FIXME: Scared idle?
		"		 TASK_FACE_ENEMY			0"
		""
		"	Interrupts"
		"		COND_GIVE_WAY"
		"		COND_PLAYER_PUSHING"
	);

	DEFINE_SCHEDULE
	(
		SCHED_INJURED_RUN_FROM_ENEMY,

		"	Tasks"
		"		TASK_SET_FAIL_SCHEDULE			SCHEDULE:SCHED_INJURED_COWER"
		"		TASK_STOP_MOVING				0"
		"		TASK_FIND_COVER_FROM_ENEMY		0"
		"		TASK_RUN_PATH					0"
		"		TASK_WAIT_FOR_MOVEMENT			0"
		""
		"	Interrupts"
	);

	AI_END_CUSTOM_SCHEDULE_PROVIDER()
}

//-----------------------------------------------------------------------------
// CAI_InjuredFollowGoal
//-----------------------------------------------------------------------------

BEGIN_DATADESC( CAI_InjuredFollowGoal )
END_DATADESC()

LINK_ENTITY_TO_CLASS( ai_goal_injured_follow, CAI_InjuredFollowGoal );

//-------------------------------------

void CAI_InjuredFollowGoal::EnableGoal( CAI_BaseNPC *pAI )
{
	CAI_BehaviorAlyxInjured *pBehavior;
	if ( !pAI->GetBehavior( &pBehavior ) )
		return;

	if ( GetGoalEntity() == NULL )
		return;
	
	pBehavior->SetFollowGoal( this );
}

//-------------------------------------

void CAI_InjuredFollowGoal::DisableGoal( CAI_BaseNPC *pAI  )
{ 
	CAI_BehaviorAlyxInjured *pBehavior;
	if ( !pAI->GetBehavior( &pBehavior ) )
		return;

	pBehavior->ClearFollowGoal( this );
}