H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-29 09:33:00 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
79e83bb97f
source-engine/game/server/ai_behavior_standoff.cpp

1337 lines
37 KiB
C++
Raw Normal View History

1
2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Combat behaviors for AIs in a relatively self-preservationist mode.
// Lots of cover taking and attempted shots out of cover.
//
//=============================================================================//
#include "cbase.h"
#include "ai_hint.h"
#include "ai_node.h"
#include "ai_navigator.h"
#include "ai_tacticalservices.h"
#include "ai_behavior_standoff.h"
#include "ai_senses.h"
#include "ai_squad.h"
#include "ai_goalentity.h"
#include "ndebugoverlay.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#define GOAL_POSITION_INVALID Vector( FLT_MAX, FLT_MAX, FLT_MAX )
ConVar DrawBattleLines( "ai_drawbattlelines", "0", FCVAR_CHEAT );
static AI_StandoffParams_t AI_DEFAULT_STANDOFF_PARAMS = { AIHCR_MOVE_ON_COVER, true, true, 2.5, 1., 3, 25, 0, false, 0.f };
#define MAKE_ACTMAP_KEY( posture, activity ) ( (((unsigned)(posture)) << 16) | ((unsigned)(activity)) )
// #define DEBUG_STANDOFF 1
#ifdef DEBUG_STANDOFF
#define StandoffMsg( msg ) DevMsg( GetOuter(), msg )
#define StandoffMsg1( msg, a ) DevMsg( GetOuter(), msg, a )
#define StandoffMsg2( msg, a, b ) DevMsg( GetOuter(), msg, a, b )
#define StandoffMsg3( msg, a, b, c ) DevMsg( GetOuter(), msg, a, b, c )
#define StandoffMsg4( msg, a, b, c, d ) DevMsg( GetOuter(), msg, a, b, c, d )
#define StandoffMsg5( msg, a, b, c, d, e ) DevMsg( GetOuter(), msg, a, b, c, d, e )
#else
#define StandoffMsg( msg ) ((void)0)
#define StandoffMsg1( msg, a ) ((void)0)
#define StandoffMsg2( msg, a, b ) ((void)0)
#define StandoffMsg3( msg, a, b, c ) ((void)0)
#define StandoffMsg4( msg, a, b, c, d ) ((void)0)
#define StandoffMsg5( msg, a, b, c, d, e ) ((void)0)
#endif
//-----------------------------------------------------------------------------
//
// CAI_BattleLine
//
//-----------------------------------------------------------------------------
const float AIBL_THINK_INTERVAL = 0.3;
class CAI_BattleLine : public CBaseEntity
{
DECLARE_CLASS( CAI_BattleLine, CBaseEntity );
public:
string_t m_iszActor;
bool m_fActive;
bool m_fStrict;
void Spawn()
{
if ( m_fActive )
{
SetThink(&CAI_BattleLine::MovementThink);
SetNextThink( gpGlobals->curtime + AIBL_THINK_INTERVAL );
m_SelfMoveMonitor.SetMark( this, 60 );
}
}
virtual void InputActivate( inputdata_t &inputdata )
{
if ( !m_fActive )
{
m_fActive = true;
NotifyChangeTacticalConstraints();
SetThink(&CAI_BattleLine::MovementThink);
SetNextThink( gpGlobals->curtime + AIBL_THINK_INTERVAL );
m_SelfMoveMonitor.SetMark( this, 60 );
}
}
virtual void InputDeactivate( inputdata_t &inputdata )
{
if ( m_fActive )
{
m_fActive = false;
NotifyChangeTacticalConstraints();
SetThink(NULL);
}
}
void UpdateOnRemove()
{
if ( m_fActive )
{
m_fActive = false;
NotifyChangeTacticalConstraints();
}
BaseClass::UpdateOnRemove();
}
bool Affects( CAI_BaseNPC *pNpc )
{
const char *pszNamedActor = STRING( m_iszActor );
if ( pNpc->NameMatches( pszNamedActor ) ||
pNpc->ClassMatches( pszNamedActor ) ||
( pNpc->GetSquad() && stricmp( pNpc->GetSquad()->GetName(), pszNamedActor ) == 0 ) )
{
return true;
}
return false;
}
void MovementThink()
{
if ( m_SelfMoveMonitor.TargetMoved( this ) )
{
NotifyChangeTacticalConstraints();
m_SelfMoveMonitor.SetMark( this, 60 );
}
SetNextThink( gpGlobals->curtime + AIBL_THINK_INTERVAL );
}
private:
void NotifyChangeTacticalConstraints()
{
for ( int i = 0; i < g_AI_Manager.NumAIs(); i++ )
{
CAI_BaseNPC *pNpc = (g_AI_Manager.AccessAIs())[i];
if ( Affects( pNpc ) )
{
CAI_StandoffBehavior *pBehavior;
if ( pNpc->GetBehavior( &pBehavior ) )
{
pBehavior->OnChangeTacticalConstraints();
}
}
}
}
CAI_MoveMonitor m_SelfMoveMonitor;
DECLARE_DATADESC();
};
//-------------------------------------
LINK_ENTITY_TO_CLASS( ai_battle_line, CAI_BattleLine );
BEGIN_DATADESC( CAI_BattleLine )
DEFINE_KEYFIELD( m_iszActor, FIELD_STRING, "Actor" ),
DEFINE_KEYFIELD( m_fActive, FIELD_BOOLEAN, "Active" ),
DEFINE_KEYFIELD( m_fStrict, FIELD_BOOLEAN, "Strict" ),
DEFINE_EMBEDDED( m_SelfMoveMonitor ),
// Inputs
DEFINE_INPUTFUNC( FIELD_VOID, "Activate", InputActivate ),
DEFINE_INPUTFUNC( FIELD_VOID, "Deactivate", InputDeactivate ),
DEFINE_THINKFUNC( MovementThink ),
END_DATADESC()
//-----------------------------------------------------------------------------
//
// CAI_StandoffBehavior
//
//-----------------------------------------------------------------------------
BEGIN_SIMPLE_DATADESC( AI_StandoffParams_t )
DEFINE_FIELD( hintChangeReaction, FIELD_INTEGER ),
DEFINE_FIELD( fPlayerIsBattleline, FIELD_BOOLEAN ),
DEFINE_FIELD( fCoverOnReload, FIELD_BOOLEAN ),
DEFINE_FIELD( minTimeShots, FIELD_FLOAT ),
DEFINE_FIELD( maxTimeShots, FIELD_FLOAT ),
DEFINE_FIELD( minShots, FIELD_INTEGER ),
DEFINE_FIELD( maxShots, FIELD_INTEGER ),
DEFINE_FIELD( oddsCover, FIELD_INTEGER ),
DEFINE_FIELD( fStayAtCover, FIELD_BOOLEAN ),
DEFINE_FIELD( flAbandonTimeLimit, FIELD_FLOAT ),
END_DATADESC();
BEGIN_DATADESC( CAI_StandoffBehavior )
DEFINE_FIELD( m_fActive, FIELD_BOOLEAN ),
DEFINE_FIELD( m_fTestNoDamage, FIELD_BOOLEAN ),
DEFINE_FIELD( m_vecStandoffGoalPosition, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( m_posture, FIELD_INTEGER ),
DEFINE_EMBEDDED( m_params ),
DEFINE_FIELD( m_hStandoffGoal, FIELD_EHANDLE ),
DEFINE_FIELD( m_fTakeCover, FIELD_BOOLEAN ),
DEFINE_FIELD( m_SavedDistTooFar, FIELD_FLOAT ),
DEFINE_FIELD( m_fForceNewEnemy, FIELD_BOOLEAN ),
DEFINE_EMBEDDED( m_PlayerMoveMonitor ),
DEFINE_EMBEDDED( m_TimeForceCoverHint ),
DEFINE_EMBEDDED( m_TimePreventForceNewEnemy ),
DEFINE_EMBEDDED( m_RandomCoverChangeTimer ),
// m_UpdateBattleLinesSemaphore (not saved, only an in-think item)
// m_BattleLines (not saved, rebuilt)
DEFINE_FIELD( m_fIgnoreFronts, FIELD_BOOLEAN ),
// m_ActivityMap (not saved, rebuilt)
// m_bHasLowCoverActivity (not saved, rebuilt)
DEFINE_FIELD( m_nSavedMinShots, FIELD_INTEGER ),
DEFINE_FIELD( m_nSavedMaxShots, FIELD_INTEGER ),
DEFINE_FIELD( m_flSavedMinRest, FIELD_FLOAT ),
DEFINE_FIELD( m_flSavedMaxRest, FIELD_FLOAT ),
END_DATADESC();
//-------------------------------------
CAI_StandoffBehavior::CAI_StandoffBehavior( CAI_BaseNPC *pOuter )
: CAI_MappedActivityBehavior_Temporary( pOuter )
{
m_fActive = false;
SetParameters( AI_DEFAULT_STANDOFF_PARAMS );
SetPosture( AIP_STANDING );
m_SavedDistTooFar = FLT_MAX;
m_fForceNewEnemy = false;
m_TimePreventForceNewEnemy.Set( 3.0, 6.0 );
m_fIgnoreFronts = false;
m_bHasLowCoverActivity = false;
}
//-------------------------------------
void CAI_StandoffBehavior::SetActive( bool fActive )
{
if ( fActive != m_fActive )
{
if ( fActive )
{
GetOuter()->SpeakSentence( STANDOFF_SENTENCE_BEGIN_STANDOFF );
}
else
{
GetOuter()->SpeakSentence( STANDOFF_SENTENCE_END_STANDOFF );
}
m_fActive = fActive;
NotifyChangeBehaviorStatus();
}
}
//-------------------------------------
void CAI_StandoffBehavior::SetParameters( const AI_StandoffParams_t &params, CAI_GoalEntity *pGoalEntity )
{
m_params = params;
m_hStandoffGoal = pGoalEntity;
m_vecStandoffGoalPosition = GOAL_POSITION_INVALID;
if ( GetOuter() && GetOuter()->GetShotRegulator() )
{
GetOuter()->GetShotRegulator()->SetBurstShotCountRange( m_params.minShots, m_params.maxShots );
GetOuter()->GetShotRegulator()->SetRestInterval( m_params.minTimeShots, m_params.maxTimeShots );
}
}
//-------------------------------------
bool CAI_StandoffBehavior::CanSelectSchedule()
{
if ( !m_bHasLowCoverActivity )
m_fActive = false;
if ( !m_fActive )
return false;
return ( GetNpcState() == NPC_STATE_COMBAT && GetOuter()->GetActiveWeapon() != NULL );
}
//-------------------------------------
void CAI_StandoffBehavior::Spawn()
{
BaseClass::Spawn();
UpdateTranslateActivityMap();
}
//-------------------------------------
void CAI_StandoffBehavior::BeginScheduleSelection()
{
m_fTakeCover = true;
// FIXME: Improve!!!
GetOuter()->GetShotRegulator()->GetBurstShotCountRange( &m_nSavedMinShots, &m_nSavedMaxShots );
GetOuter()->GetShotRegulator()->GetRestInterval( &m_flSavedMinRest, &m_flSavedMaxRest );
GetOuter()->GetShotRegulator()->SetBurstShotCountRange( m_params.minShots, m_params.maxShots );
GetOuter()->GetShotRegulator()->SetRestInterval( m_params.minTimeShots, m_params.maxTimeShots );
GetOuter()->GetShotRegulator()->Reset();
m_SavedDistTooFar = GetOuter()->m_flDistTooFar;
GetOuter()->m_flDistTooFar = FLT_MAX;
m_TimeForceCoverHint.Set( 8, false );
m_RandomCoverChangeTimer.Set( 8, 16, false );
UpdateTranslateActivityMap();
}
void CAI_StandoffBehavior::OnUpdateShotRegulator()
{
GetOuter()->GetShotRegulator()->SetBurstShotCountRange( m_params.minShots, m_params.maxShots );
GetOuter()->GetShotRegulator()->SetRestInterval( m_params.minTimeShots, m_params.maxTimeShots );
}
//-------------------------------------
void CAI_StandoffBehavior::EndScheduleSelection()
{
UnlockHintNode();
m_vecStandoffGoalPosition = GOAL_POSITION_INVALID;
GetOuter()->m_flDistTooFar = m_SavedDistTooFar;
// FIXME: Improve!!!
GetOuter()->GetShotRegulator()->SetBurstShotCountRange( m_nSavedMinShots, m_nSavedMaxShots );
GetOuter()->GetShotRegulator()->SetRestInterval( m_flSavedMinRest, m_flSavedMaxRest );
}
//-------------------------------------
void CAI_StandoffBehavior::PrescheduleThink()
{
VPROF_BUDGET( "CAI_StandoffBehavior::PrescheduleThink", VPROF_BUDGETGROUP_NPCS );
BaseClass::PrescheduleThink();
if( DrawBattleLines.GetInt() != 0 )
{
CBaseEntity *pEntity = NULL;
while ((pEntity = gEntList.FindEntityByClassname( pEntity, "ai_battle_line" )) != NULL)
{
// Visualize the battle line and its normal.
CAI_BattleLine *pLine = dynamic_cast<CAI_BattleLine *>(pEntity);
if( pLine->m_fActive )
{
Vector normal;
pLine->GetVectors( &normal, NULL, NULL );
NDebugOverlay::Line( pLine->GetAbsOrigin() - Vector( 0, 0, 64 ), pLine->GetAbsOrigin() + Vector(0,0,64), 0,255,0, false, 0.1 );
}
}
}
}
//-------------------------------------
void CAI_StandoffBehavior::GatherConditions()
{
CBaseEntity *pLeader = GetPlayerLeader();
if ( pLeader && m_TimeForceCoverHint.Expired() )
{
if ( m_PlayerMoveMonitor.IsMarkSet() )
{
if (m_PlayerMoveMonitor.TargetMoved( pLeader ) )
{
OnChangeTacticalConstraints();
m_PlayerMoveMonitor.ClearMark();
}
}
else
{
m_PlayerMoveMonitor.SetMark( pLeader, 60 );
}
}
if ( m_fForceNewEnemy )
{
m_TimePreventForceNewEnemy.Reset();
GetOuter()->SetEnemy( NULL );
}
BaseClass::GatherConditions();
m_fForceNewEnemy = false;
ClearCondition( COND_ABANDON_TIME_EXPIRED );
bool bAbandonStandoff = false;
CAI_Squad *pSquad = GetOuter()->GetSquad();
AISquadIter_t iter;
if ( GetEnemy() )
{
AI_EnemyInfo_t *pEnemyInfo = GetOuter()->GetEnemies()->Find( GetEnemy() );
if ( pEnemyInfo &&
m_params.flAbandonTimeLimit > 0 &&
( ( pEnemyInfo->timeAtFirstHand != AI_INVALID_TIME &&
gpGlobals->curtime - pEnemyInfo->timeLastSeen > m_params.flAbandonTimeLimit ) ||
( pEnemyInfo->timeAtFirstHand == AI_INVALID_TIME &&
gpGlobals->curtime - pEnemyInfo->timeFirstSeen > m_params.flAbandonTimeLimit * 2 ) ) )
{
SetCondition( COND_ABANDON_TIME_EXPIRED );
bAbandonStandoff = true;
if ( pSquad )
{
for ( CAI_BaseNPC *pSquadMate = pSquad->GetFirstMember( &iter ); pSquadMate; pSquadMate = pSquad->GetNextMember( &iter ) )
{
if ( pSquadMate->IsAlive() && pSquadMate != GetOuter() )
{
CAI_StandoffBehavior *pSquadmateStandoff;
pSquadMate->GetBehavior( &pSquadmateStandoff );
if ( pSquadmateStandoff && pSquadmateStandoff->IsActive() &&
pSquadmateStandoff->m_hStandoffGoal == m_hStandoffGoal &&
!pSquadmateStandoff->HasCondition( COND_ABANDON_TIME_EXPIRED ) )
{
bAbandonStandoff = false;
break;
}
}
}
}
}
}
if ( bAbandonStandoff )
{
if ( pSquad )
{
for ( CAI_BaseNPC *pSquadMate = pSquad->GetFirstMember( &iter ); pSquadMate; pSquadMate = pSquad->GetNextMember( &iter ) )
{
CAI_StandoffBehavior *pSquadmateStandoff;
pSquadMate->GetBehavior( &pSquadmateStandoff );
if ( pSquadmateStandoff && pSquadmateStandoff->IsActive() && pSquadmateStandoff->m_hStandoffGoal == m_hStandoffGoal )
pSquadmateStandoff->SetActive( false );
}
}
else
SetActive( false );
}
else if ( GetOuter()->m_debugOverlays & OVERLAY_NPC_SELECTED_BIT )
{
if( DrawBattleLines.GetInt() != 0 )
{
if ( IsBehindBattleLines( GetAbsOrigin() ) )
{
NDebugOverlay::Box( GetOuter()->GetAbsOrigin(), -Vector(48,48,4), Vector(48,48,4), 255,0,0,8, 0.1 );
}
else
{
NDebugOverlay::Box( GetOuter()->GetAbsOrigin(), -Vector(48,48,4), Vector(48,48,4), 0,255,0,8, 0.1 );
}
}
}
}
//-------------------------------------
int CAI_StandoffBehavior::SelectScheduleUpdateWeapon( void )
{
// Check if need to reload
if ( HasCondition ( COND_NO_PRIMARY_AMMO ) || HasCondition ( COND_LOW_PRIMARY_AMMO ))
{
StandoffMsg( "Out of ammo, reloading\n" );
if ( m_params.fCoverOnReload )
{
GetOuter()->SpeakSentence( STANDOFF_SENTENCE_OUT_OF_AMMO );
return SCHED_HIDE_AND_RELOAD;
}
return SCHED_RELOAD;
}
// Otherwise, update planned shots to fire before taking cover again
if ( HasCondition( COND_LIGHT_DAMAGE ) )
{
// if hurt:
int iPercent = random->RandomInt(0,99);
if ( iPercent <= m_params.oddsCover && GetEnemy() != NULL )
{
SetReuseCurrentCover();
StandoffMsg( "Hurt, firing one more shot before cover\n" );
if ( !GetOuter()->GetShotRegulator()->IsInRestInterval() )
{
GetOuter()->GetShotRegulator()->SetBurstShotsRemaining( 1 );
}
}
}
return SCHED_NONE;
}
//-------------------------------------
int CAI_StandoffBehavior::SelectScheduleCheckCover( void )
{
if ( m_fTakeCover )
{
m_fTakeCover = false;
if ( GetEnemy() )
{
GetOuter()->SpeakSentence( STANDOFF_SENTENCE_FORCED_TAKE_COVER );
StandoffMsg( "Taking forced cover\n" );
return SCHED_TAKE_COVER_FROM_ENEMY;
}
}
if ( GetOuter()->GetShotRegulator()->IsInRestInterval() )
{
StandoffMsg( "Regulated to not shoot\n" );
if ( GetHintType() == HINT_TACTICAL_COVER_LOW )
SetPosture( AIP_CROUCHING );
else
SetPosture( AIP_STANDING );
if ( random->RandomInt(0,99) < 80 )
SetReuseCurrentCover();
return SCHED_TAKE_COVER_FROM_ENEMY;
}
return SCHED_NONE;
}
//-------------------------------------
int CAI_StandoffBehavior::SelectScheduleEstablishAim( void )
{
if ( HasCondition( COND_ENEMY_OCCLUDED ) )
{
if ( GetPosture() == AIP_CROUCHING )
{
// force a stand up, just in case
GetOuter()->SpeakSentence( STANDOFF_SENTENCE_STAND_CHECK_TARGET );
StandoffMsg( "Crouching, standing up to gain LOS\n" );
SetPosture( AIP_PEEKING );
return SCHED_STANDOFF;
}
else if ( GetPosture() == AIP_PEEKING )
{
if ( m_TimePreventForceNewEnemy.Expired() )
{
// Look for a new enemy
m_fForceNewEnemy = true;
StandoffMsg( "Looking for enemy\n" );
}
}
#if 0
else
{
return SCHED_ESTABLISH_LINE_OF_FIRE;
}
#endif
}
return SCHED_NONE;
}
//-------------------------------------
int CAI_StandoffBehavior::SelectScheduleAttack( void )
{
if ( GetPosture() == AIP_PEEKING || GetPosture() == AIP_STANDING )
{
if ( !HasCondition( COND_CAN_RANGE_ATTACK1 ) &&
!HasCondition( COND_CAN_MELEE_ATTACK1 ) &&
HasCondition( COND_TOO_FAR_TO_ATTACK ) )
{
if ( GetOuter()->GetActiveWeapon() && ( GetOuter()->GetActiveWeapon()->CapabilitiesGet() & bits_CAP_WEAPON_RANGE_ATTACK1 ) )
{
if ( !HasCondition( COND_ENEMY_OCCLUDED ) || random->RandomInt(0,99) < 50 )
// Don't advance, just fire anyway
return SCHED_RANGE_ATTACK1;
}
}
}
return SCHED_NONE;
}
//-------------------------------------
int CAI_StandoffBehavior::SelectSchedule( void )
{
switch ( GetNpcState() )
{
case NPC_STATE_COMBAT:
{
int schedule = SCHED_NONE;
schedule = SelectScheduleUpdateWeapon();
if ( schedule != SCHED_NONE )
return schedule;
schedule = SelectScheduleCheckCover();
if ( schedule != SCHED_NONE )
return schedule;
schedule = SelectScheduleEstablishAim();
if ( schedule != SCHED_NONE )
return schedule;
schedule = SelectScheduleAttack();
if ( schedule != SCHED_NONE )
return schedule;
break;
}
}
return BaseClass::SelectSchedule();
}
//-------------------------------------
int CAI_StandoffBehavior::TranslateSchedule( int schedule )
{
if ( schedule == SCHED_CHASE_ENEMY )
{
StandoffMsg( "trying SCHED_ESTABLISH_LINE_OF_FIRE\n" );
return SCHED_ESTABLISH_LINE_OF_FIRE;
}
return BaseClass::TranslateSchedule( schedule );
}
//-------------------------------------
void CAI_StandoffBehavior::BuildScheduleTestBits()
{
BaseClass::BuildScheduleTestBits();
if ( IsCurSchedule( SCHED_TAKE_COVER_FROM_ENEMY ) )
GetOuter()->ClearCustomInterruptCondition( COND_NEW_ENEMY );
}
//-------------------------------------
Activity CAI_MappedActivityBehavior_Temporary::GetMappedActivity( AI_Posture_t posture, Activity activity )
{
if ( posture != AIP_STANDING )
{
unsigned short iActivityTranslation = m_ActivityMap.Find( MAKE_ACTMAP_KEY( posture, activity ) );
if ( iActivityTranslation != m_ActivityMap.InvalidIndex() )
{
Activity result = m_ActivityMap[iActivityTranslation];
return result;
}
}
return ACT_INVALID;
}
//-------------------------------------
Activity CAI_StandoffBehavior::NPC_TranslateActivity( Activity activity )
{
Activity coverActivity = GetCoverActivity();
if ( coverActivity != ACT_INVALID )
{
if ( activity == ACT_IDLE )
activity = coverActivity;
if ( GetPosture() == AIP_STANDING && coverActivity == ACT_COVER_LOW )
SetPosture( AIP_CROUCHING );
}
Activity result = GetMappedActivity( GetPosture(), activity );
if ( result != ACT_INVALID)
return result;
return BaseClass::NPC_TranslateActivity( activity );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &vecPos -
//-----------------------------------------------------------------------------
void CAI_StandoffBehavior::SetStandoffGoalPosition( const Vector &vecPos )
{
m_vecStandoffGoalPosition = vecPos;
UpdateBattleLines();
OnChangeTacticalConstraints();
GetOuter()->ClearSchedule( "Standoff goal position changed" );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &vecPos -
//-----------------------------------------------------------------------------
void CAI_StandoffBehavior::ClearStandoffGoalPosition()
{
if ( m_vecStandoffGoalPosition != GOAL_POSITION_INVALID )
{
m_vecStandoffGoalPosition = GOAL_POSITION_INVALID;
UpdateBattleLines();
OnChangeTacticalConstraints();
GetOuter()->ClearSchedule( "Standoff goal position cleared" );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Vector
//-----------------------------------------------------------------------------
Vector CAI_StandoffBehavior::GetStandoffGoalPosition()
{
if( m_vecStandoffGoalPosition != GOAL_POSITION_INVALID )
{
return m_vecStandoffGoalPosition;
}
else if( PlayerIsLeading() )
{
return UTIL_GetLocalPlayer()->GetAbsOrigin();
}
else
{
CAI_BattleLine *pBattleLine = NULL;
for (;;)
{
pBattleLine = (CAI_BattleLine *)gEntList.FindEntityByClassname( pBattleLine, "ai_battle_line" );
if ( !pBattleLine )
break;
if ( pBattleLine->m_fActive && pBattleLine->Affects( GetOuter() ) )
{
StandoffMsg1( "Using battleline %s as goal\n", STRING( pBattleLine->GetEntityName() ) );
return pBattleLine->GetAbsOrigin();
}
}
}
return GetAbsOrigin();
}
//-------------------------------------
void CAI_StandoffBehavior::UpdateBattleLines()
{
if ( m_UpdateBattleLinesSemaphore.EnterThink() )
{
// @TODO (toml 06-19-03): This is the quick to code thing. Could use some optimization/caching to not recalc everything (up to) each think
m_BattleLines.RemoveAll();
bool bHaveGoalPosition = ( m_vecStandoffGoalPosition != GOAL_POSITION_INVALID );
if ( bHaveGoalPosition )
{
// If we have a valid standoff goal position, it takes precendence.
const float DIST_GOAL_PLANE = 180;
BattleLine_t goalLine;
if ( GetDirectionOfStandoff( &goalLine.normal ) )
{
goalLine.point = GetStandoffGoalPosition() + goalLine.normal * DIST_GOAL_PLANE;
m_BattleLines.AddToTail( goalLine );
}
}
else if ( PlayerIsLeading() && GetEnemy() )
{
if ( m_params.fPlayerIsBattleline )
{
const float DIST_PLAYER_PLANE = 180;
CBaseEntity *pPlayer = UTIL_GetLocalPlayer();
BattleLine_t playerLine;
if ( GetDirectionOfStandoff( &playerLine.normal ) )
{
playerLine.point = pPlayer->GetAbsOrigin() + playerLine.normal * DIST_PLAYER_PLANE;
m_BattleLines.AddToTail( playerLine );
}
}
}
CAI_BattleLine *pBattleLine = NULL;
for (;;)
{
pBattleLine = (CAI_BattleLine *)gEntList.FindEntityByClassname( pBattleLine, "ai_battle_line" );
if ( !pBattleLine )
break;
if ( pBattleLine->m_fActive && (pBattleLine->m_fStrict || !bHaveGoalPosition ) && pBattleLine->Affects( GetOuter() ) )
{
BattleLine_t battleLine;
battleLine.point = pBattleLine->GetAbsOrigin();
battleLine.normal = UTIL_YawToVector( pBattleLine->GetAbsAngles().y );
m_BattleLines.AddToTail( battleLine );
}
}
}
}
//-------------------------------------
bool CAI_StandoffBehavior::IsBehindBattleLines( const Vector &point )
{
UpdateBattleLines();
Vector vecToPoint;
for ( int i = 0; i < m_BattleLines.Count(); i++ )
{
vecToPoint = point - m_BattleLines[i].point;
VectorNormalize( vecToPoint );
vecToPoint.z = 0;
if ( DotProduct( m_BattleLines[i].normal, vecToPoint ) > 0 )
{
if( DrawBattleLines.GetInt() != 0 )
{
NDebugOverlay::Box( point, -Vector(48,48,4), Vector(48,48,4), 0,255,0,8, 1 );
NDebugOverlay::Line( point, GetOuter()->GetAbsOrigin(), 0,255,0,true, 1 );
}
return false;
}
}
if( DrawBattleLines.GetInt() != 0 )
{
NDebugOverlay::Box( point, -Vector(48,48,4), Vector(48,48,4), 255,0,0,8, 1 );
NDebugOverlay::Line( point, GetOuter()->GetAbsOrigin(), 255,0,0,true, 1 );
}
return true;
}
//-------------------------------------
bool CAI_StandoffBehavior::IsValidCover( const Vector &vecCoverLocation, const CAI_Hint *pHint )
{
if ( !BaseClass::IsValidCover( vecCoverLocation, pHint ) )
return false;
if ( IsCurSchedule( SCHED_TAKE_COVER_FROM_BEST_SOUND ) )
return true;
return ( m_fIgnoreFronts || IsBehindBattleLines( vecCoverLocation ) );
}
//-------------------------------------
bool CAI_StandoffBehavior::IsValidShootPosition( const Vector &vLocation, CAI_Node *pNode, const CAI_Hint *pHint )
{
if ( !BaseClass::IsValidShootPosition( vLocation, pNode, pHint ) )
return false;
return ( m_fIgnoreFronts || IsBehindBattleLines( vLocation ) );
}
//-------------------------------------
void CAI_StandoffBehavior::StartTask( const Task_t *pTask )
{
bool fCallBase = false;
switch ( pTask->iTask )
{
case TASK_RANGE_ATTACK1:
{
fCallBase = true;
break;
}
case TASK_FIND_COVER_FROM_ENEMY:
{
StandoffMsg( "TASK_FIND_COVER_FROM_ENEMY\n" );
// If within time window to force change
if ( !m_params.fStayAtCover && (!m_TimeForceCoverHint.Expired() || m_RandomCoverChangeTimer.Expired()) )
{
m_TimeForceCoverHint.Force();
m_RandomCoverChangeTimer.Set( 8, 16, false );
// @TODO (toml 03-24-03): clean this up be tool-izing base tasks. Right now, this is here to force to not use lateral cover search
CBaseEntity *pEntity = GetEnemy();
if ( pEntity == NULL )
{
// Find cover from self if no enemy available
pEntity = GetOuter();
}
CBaseEntity *pLeader = GetPlayerLeader();
if ( pLeader )
{
m_PlayerMoveMonitor.SetMark( pLeader, 60 );
}
Vector coverPos = vec3_origin;
CAI_TacticalServices * pTacticalServices = GetTacticalServices();
const Vector & enemyPos = pEntity->GetAbsOrigin();
Vector enemyEyePos = pEntity->EyePosition();
float coverRadius = GetOuter()->CoverRadius();
const Vector & goalPos = GetStandoffGoalPosition();
bool bTryGoalPosFirst = true;
if( pLeader && m_vecStandoffGoalPosition == GOAL_POSITION_INVALID )
{
if( random->RandomInt(1, 100) <= 50 )
{
// Half the time, if the player is leading, try to find a spot near them
bTryGoalPosFirst = false;
StandoffMsg( "Not trying goal pos\n" );
}
}
if( bTryGoalPosFirst )
{
// Firstly, try to find cover near the goal position.
pTacticalServices->FindCoverPos( goalPos, enemyPos, enemyEyePos, 0, 15*12, &coverPos );
if ( coverPos == vec3_origin )
pTacticalServices->FindCoverPos( goalPos, enemyPos, enemyEyePos, 15*12-0.1, 40*12, &coverPos );
StandoffMsg1( "Trying goal pos, %s\n", ( coverPos == vec3_origin ) ? "failed" : "succeeded" );
}
if ( coverPos == vec3_origin )
{
// Otherwise, find a node near to self
StandoffMsg( "Looking for near cover\n" );
if ( !GetTacticalServices()->FindCoverPos( enemyPos, enemyEyePos, 0, coverRadius, &coverPos ) )
{
// Try local lateral cover
if ( !GetTacticalServices()->FindLateralCover( enemyEyePos, 0, &coverPos ) )
{
// At this point, try again ignoring front lines. Any cover probably better than hanging out in the open
m_fIgnoreFronts = true;
if ( !GetTacticalServices()->FindCoverPos( enemyPos, enemyEyePos, 0, coverRadius, &coverPos ) )
{
if ( !GetTacticalServices()->FindLateralCover( enemyEyePos, 0, &coverPos ) )
{
Assert( coverPos == vec3_origin );
}
}
m_fIgnoreFronts = false;
}
}
}
if ( coverPos != vec3_origin )
{
AI_NavGoal_t goal(GOALTYPE_COVER, coverPos, ACT_RUN, AIN_HULL_TOLERANCE, AIN_DEF_FLAGS);
GetNavigator()->SetGoal( goal );
GetOuter()->m_flMoveWaitFinished = gpGlobals->curtime + pTask->flTaskData;
TaskComplete();
}
else
TaskFail(FAIL_NO_COVER);
}
else
{
fCallBase = true;
}
break;
}
default:
{
fCallBase = true;
}
}
if ( fCallBase )
BaseClass::StartTask( pTask );
}
//-------------------------------------
void CAI_StandoffBehavior::OnChangeHintGroup( string_t oldGroup, string_t newGroup )
{
OnChangeTacticalConstraints();
}
//-------------------------------------
void CAI_StandoffBehavior::OnChangeTacticalConstraints()
{
if ( m_params.hintChangeReaction > AIHCR_DEFAULT_AI )
m_TimeForceCoverHint.Set( 8.0, false );
if ( m_params.hintChangeReaction == AIHCR_MOVE_IMMEDIATE )
m_fTakeCover = true;
}
//-------------------------------------
bool CAI_StandoffBehavior::PlayerIsLeading()
{
CBaseEntity *pPlayer = AI_GetSinglePlayer();
return ( pPlayer && GetOuter()->IRelationType( pPlayer ) == D_LI );
}
//-------------------------------------
CBaseEntity *CAI_StandoffBehavior::GetPlayerLeader()
{
CBaseEntity *pPlayer = AI_GetSinglePlayer();
if ( pPlayer && GetOuter()->IRelationType( pPlayer ) == D_LI )
return pPlayer;
return NULL;
}
//-------------------------------------
bool CAI_StandoffBehavior::GetDirectionOfStandoff( Vector *pDir )
{
if ( GetEnemy() )
{
*pDir = GetEnemy()->GetAbsOrigin() - GetAbsOrigin();
VectorNormalize( *pDir );
pDir->z = 0;
return true;
}
return false;
}
//-------------------------------------
Hint_e CAI_StandoffBehavior::GetHintType()
{
CAI_Hint *pHintNode = GetHintNode();
if ( pHintNode )
return pHintNode->HintType();
return HINT_NONE;
}
//-------------------------------------
void CAI_StandoffBehavior::SetReuseCurrentCover()
{
CAI_Hint *pHintNode = GetHintNode();
if ( pHintNode && pHintNode->GetNode() && pHintNode->GetNode()->IsLocked() )
pHintNode->GetNode()->Unlock();
}
//-------------------------------------
void CAI_StandoffBehavior::UnlockHintNode()
{
CAI_Hint *pHintNode = GetHintNode();
if ( pHintNode )
{
if ( pHintNode->IsLocked() && pHintNode->IsLockedBy( GetOuter() ) )
pHintNode->Unlock();
CAI_Node *pNode = pHintNode->GetNode();
if ( pNode && pNode->IsLocked() )
pNode->Unlock();
ClearHintNode();
}
}
//-------------------------------------
Activity CAI_StandoffBehavior::GetCoverActivity()
{
CAI_Hint *pHintNode = GetHintNode();
if ( pHintNode && pHintNode->HintType() == HINT_TACTICAL_COVER_LOW )
return GetOuter()->GetCoverActivity( pHintNode );
return ACT_INVALID;
}
//-------------------------------------
struct AI_ActivityMapping_t
{
AI_Posture_t posture;
Activity activity;
const char * pszWeapon;
Activity translation;
};
void CAI_MappedActivityBehavior_Temporary::UpdateTranslateActivityMap()
{
AI_ActivityMapping_t mappings[] = // This array cannot be static, as some activity values are set on a per-map-load basis
{
{ AIP_CROUCHING, ACT_IDLE, NULL, ACT_COVER_LOW, },
{ AIP_CROUCHING, ACT_IDLE_ANGRY, NULL, ACT_COVER_LOW, },
{ AIP_CROUCHING, ACT_WALK, NULL, ACT_WALK_CROUCH, },
{ AIP_CROUCHING, ACT_RUN, NULL, ACT_RUN_CROUCH, },
{ AIP_CROUCHING, ACT_WALK_AIM, NULL, ACT_WALK_CROUCH_AIM, },
{ AIP_CROUCHING, ACT_RUN_AIM, NULL, ACT_RUN_CROUCH_AIM, },
{ AIP_CROUCHING, ACT_RELOAD, NULL, ACT_RELOAD_LOW, },
{ AIP_CROUCHING, ACT_RANGE_ATTACK_SMG1, NULL, ACT_RANGE_ATTACK_SMG1_LOW, },
{ AIP_CROUCHING, ACT_RANGE_ATTACK_AR2, NULL, ACT_RANGE_ATTACK_AR2_LOW, },
//----
{ AIP_PEEKING, ACT_IDLE, NULL, ACT_RANGE_AIM_LOW, },
{ AIP_PEEKING, ACT_IDLE_ANGRY, NULL, ACT_RANGE_AIM_LOW, },
{ AIP_PEEKING, ACT_COVER_LOW, NULL, ACT_RANGE_AIM_LOW, },
{ AIP_PEEKING, ACT_RANGE_ATTACK1, NULL, ACT_RANGE_ATTACK1_LOW, },
{ AIP_PEEKING, ACT_RELOAD, NULL, ACT_RELOAD_LOW, },
};
m_ActivityMap.RemoveAll();
CBaseCombatWeapon *pWeapon = GetOuter()->GetActiveWeapon();
const char *pszWeaponClass = ( pWeapon ) ? pWeapon->GetClassname() : "";
for ( int i = 0; i < ARRAYSIZE(mappings); i++ )
{
if ( !mappings[i].pszWeapon || stricmp( mappings[i].pszWeapon, pszWeaponClass ) == 0 )
{
if ( HaveSequenceForActivity( mappings[i].translation ) || HaveSequenceForActivity( GetOuter()->Weapon_TranslateActivity( mappings[i].translation ) ) )
{
Assert( m_ActivityMap.Find( MAKE_ACTMAP_KEY( mappings[i].posture, mappings[i].activity ) ) == m_ActivityMap.InvalidIndex() );
m_ActivityMap.Insert( MAKE_ACTMAP_KEY( mappings[i].posture, mappings[i].activity ), mappings[i].translation );
}
}
}
}
void CAI_StandoffBehavior::UpdateTranslateActivityMap()
{
BaseClass::UpdateTranslateActivityMap();
Activity lowCoverActivity = GetMappedActivity( AIP_CROUCHING, ACT_COVER_LOW );
if ( lowCoverActivity == ACT_INVALID )
lowCoverActivity = ACT_COVER_LOW;
m_bHasLowCoverActivity = ( ( CapabilitiesGet() & bits_CAP_DUCK ) && (GetOuter()->TranslateActivity( lowCoverActivity ) != ACT_INVALID));
CBaseCombatWeapon *pWeapon = GetOuter()->GetActiveWeapon();
if ( pWeapon && (GetOuter()->TranslateActivity( lowCoverActivity ) == ACT_INVALID ))
DevMsg( "Note: NPC class %s lacks ACT_COVER_LOW, therefore cannot participate in standoff\n", GetOuter()->GetClassname() );
}
//-------------------------------------
void CAI_MappedActivityBehavior_Temporary::OnChangeActiveWeapon( CBaseCombatWeapon *pOldWeapon, CBaseCombatWeapon *pNewWeapon )
{
UpdateTranslateActivityMap();
}
//-------------------------------------
void CAI_StandoffBehavior::OnRestore()
{
UpdateTranslateActivityMap();
}
//-------------------------------------
AI_BEGIN_CUSTOM_SCHEDULE_PROVIDER(CAI_StandoffBehavior)
DECLARE_CONDITION( COND_ABANDON_TIME_EXPIRED )
AI_END_CUSTOM_SCHEDULE_PROVIDER()
//-----------------------------------------------------------------------------
//
// CAI_StandoffGoal
//
// Purpose: A level tool to control the standoff behavior. Use is not required
// in order to use behavior.
//
//-----------------------------------------------------------------------------
AI_StandoffParams_t g_StandoffParamsByAgression[] =
{
// hintChangeReaction, fCoverOnReload, PlayerBtlLn, minTimeShots, maxTimeShots, minShots, maxShots, oddsCover flAbandonTimeLimit
{ AIHCR_MOVE_ON_COVER, true, true, 4.0, 8.0, 2, 4, 50, false, 30 }, // AGGR_VERY_LOW
{ AIHCR_MOVE_ON_COVER, true, true, 2.0, 5.0, 3, 5, 25, false, 20 }, // AGGR_LOW
{ AIHCR_MOVE_ON_COVER, true, true, 0.6, 2.5, 3, 6, 25, false, 10 }, // AGGR_MEDIUM
{ AIHCR_MOVE_ON_COVER, true, true, 0.2, 1.5, 5, 8, 10, false, 10 }, // AGGR_HIGH
{ AIHCR_MOVE_ON_COVER, false, true, 0, 0, 100, 100, 0, false, 5 }, // AGGR_VERY_HIGH
};
//-------------------------------------
class CAI_StandoffGoal : public CAI_GoalEntity
{
DECLARE_CLASS( CAI_StandoffGoal, CAI_GoalEntity );
public:
CAI_StandoffGoal()
{
m_aggressiveness = AGGR_MEDIUM;
m_fPlayerIsBattleline = true;
m_HintChangeReaction = AIHCR_DEFAULT_AI;
m_fStayAtCover = false;
m_bAbandonIfEnemyHides = false;
m_customParams = AI_DEFAULT_STANDOFF_PARAMS;
}
//---------------------------------
void EnableGoal( CAI_BaseNPC *pAI )
{
CAI_StandoffBehavior *pBehavior;
if ( !pAI->GetBehavior( &pBehavior ) )
return;
pBehavior->SetActive( true );
SetBehaviorParams( pBehavior);
}
void DisableGoal( CAI_BaseNPC *pAI )
{
// @TODO (toml 04-07-03): remove the no damage spawn flag once stable. The implementation isn't very good.
CAI_StandoffBehavior *pBehavior;
if ( !pAI->GetBehavior( &pBehavior ) )
return;
pBehavior->SetActive( false );
SetBehaviorParams( pBehavior);
}
void InputActivate( inputdata_t &inputdata )
{
ValidateAggression();
BaseClass::InputActivate( inputdata );
}
void InputDeactivate( inputdata_t &inputdata )
{
ValidateAggression();
BaseClass::InputDeactivate( inputdata );
}
void InputSetAggressiveness( inputdata_t &inputdata )
{
int newVal = inputdata.value.Int();
m_aggressiveness = (Aggressiveness_t)newVal;
ValidateAggression();
UpdateActors();
const CUtlVector<AIHANDLE> &actors = AccessActors();
for ( int i = 0; i < actors.Count(); i++ )
{
CAI_BaseNPC *pAI = actors[i];
CAI_StandoffBehavior *pBehavior;
if ( !pAI->GetBehavior( &pBehavior ) )
continue;
SetBehaviorParams( pBehavior);
}
}
void SetBehaviorParams( CAI_StandoffBehavior *pBehavior )
{
AI_StandoffParams_t params;
if ( m_aggressiveness != AGGR_CUSTOM )
params = g_StandoffParamsByAgression[m_aggressiveness];
else
params = m_customParams;
params.hintChangeReaction = m_HintChangeReaction;
params.fPlayerIsBattleline = m_fPlayerIsBattleline;
params.fStayAtCover = m_fStayAtCover;
if ( !m_bAbandonIfEnemyHides )
params.flAbandonTimeLimit = 0;
pBehavior->SetParameters( params, this );
pBehavior->OnChangeTacticalConstraints();
if ( pBehavior->IsRunning() )
pBehavior->GetOuter()->ClearSchedule( "Standoff behavior parms changed" );
}
void ValidateAggression()
{
if ( m_aggressiveness < AGGR_VERY_LOW || m_aggressiveness > AGGR_VERY_HIGH )
{
if ( m_aggressiveness != AGGR_CUSTOM )
{
DevMsg( "Invalid aggressiveness value %d\n", m_aggressiveness );
if ( m_aggressiveness < AGGR_VERY_LOW )
m_aggressiveness = AGGR_VERY_LOW;
else if ( m_aggressiveness > AGGR_VERY_HIGH )
m_aggressiveness = AGGR_VERY_HIGH;
}
}
}
private:
//---------------------------------
DECLARE_DATADESC();
enum Aggressiveness_t
{
AGGR_VERY_LOW,
AGGR_LOW,
AGGR_MEDIUM,
AGGR_HIGH,
AGGR_VERY_HIGH,
AGGR_CUSTOM,
};
Aggressiveness_t m_aggressiveness;
AI_HintChangeReaction_t m_HintChangeReaction;
bool m_fPlayerIsBattleline;
bool m_fStayAtCover;
bool m_bAbandonIfEnemyHides;
AI_StandoffParams_t m_customParams;
};
//-------------------------------------
LINK_ENTITY_TO_CLASS( ai_goal_standoff, CAI_StandoffGoal );
BEGIN_DATADESC( CAI_StandoffGoal )
DEFINE_KEYFIELD( m_aggressiveness, FIELD_INTEGER, "Aggressiveness" ),
// m_customParams (individually)
DEFINE_KEYFIELD( m_HintChangeReaction, FIELD_INTEGER, "HintGroupChangeReaction" ),
DEFINE_KEYFIELD( m_fPlayerIsBattleline, FIELD_BOOLEAN, "PlayerBattleline" ),
DEFINE_KEYFIELD( m_fStayAtCover, FIELD_BOOLEAN, "StayAtCover" ),
DEFINE_KEYFIELD( m_bAbandonIfEnemyHides, FIELD_BOOLEAN, "AbandonIfEnemyHides" ),
DEFINE_KEYFIELD( m_customParams.fCoverOnReload, FIELD_BOOLEAN, "CustomCoverOnReload" ),
DEFINE_KEYFIELD( m_customParams.minTimeShots, FIELD_FLOAT, "CustomMinTimeShots" ),
DEFINE_KEYFIELD( m_customParams.maxTimeShots, FIELD_FLOAT, "CustomMaxTimeShots" ),
DEFINE_KEYFIELD( m_customParams.minShots, FIELD_INTEGER, "CustomMinShots" ),
DEFINE_KEYFIELD( m_customParams.maxShots, FIELD_INTEGER, "CustomMaxShots" ),
DEFINE_KEYFIELD( m_customParams.oddsCover, FIELD_INTEGER, "CustomOddsCover" ),
// Inputs
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetAggressiveness", InputSetAggressiveness ),
END_DATADESC()
///-----------------------------------------------------------------------------
Reference in New Issue Copy Permalink