archive
/
tf2
mirror of https://github.com/sr2echa/TF2-Source-Code
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Team Fortress 2 Source Code as on 22/4/2020
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
8 Commits
1 Branch
0 Tags
1.4 GiB
 
 
 
 
 
 
Tree: df62d5da09
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'df62d5da09'
${ noResults }
tf2/tf2_src/game/server/ai_behavior_lead.cpp

1693 lines
46 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#undef strncpy // we use std::string below that needs a good strncpy define
#undef sprintf // "
#include "cbase.h"
#include "ai_behavior_lead.h"
#include "ai_goalentity.h"
#include "ai_navigator.h"
#include "ai_speech.h"
#include "ai_senses.h"
#include "ai_playerally.h"
#include "ai_route.h"
#include "ai_pathfinder.h"
#include "sceneentity.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
// Minimum time between leader nags
#define LEAD_NAG_TIME 3.0
#define LEAD_MIN_RETRIEVEDIST_OFFSET 24
//-----------------------------------------------------------------------------
// class CAI_LeadBehavior
//
// Purpose:
//
//-----------------------------------------------------------------------------
BEGIN_SIMPLE_DATADESC( AI_LeadArgs_t )
// Only the flags needs saving
DEFINE_FIELD( flags, FIELD_INTEGER ),
//DEFINE_FIELD( pszGoal, FIELD_STRING ),
//DEFINE_FIELD( pszWaitPoint, FIELD_STRING ),
//DEFINE_FIELD( flWaitDistance, FIELD_FLOAT ),
//DEFINE_FIELD( flLeadDistance, FIELD_FLOAT ),
//DEFINE_FIELD( flRetrieveDistance, FIELD_FLOAT ),
//DEFINE_FIELD( flSuccessDistance, FIELD_FLOAT ),
//DEFINE_FIELD( bRun, FIELD_BOOLEAN ),
//DEFINE_FIELD( bDontSpeakStart, FIELD_BOOLEAN ),
//DEFINE_FIELD( bGagLeader, FIELD_BOOLEAN ),
DEFINE_FIELD( iRetrievePlayer, FIELD_INTEGER ),
DEFINE_FIELD( iRetrieveWaitForSpeak, FIELD_INTEGER ),
DEFINE_FIELD( iComingBackWaitForSpeak, FIELD_INTEGER ),
DEFINE_FIELD( bStopScenesWhenPlayerLost, FIELD_BOOLEAN ),
DEFINE_FIELD( bLeadDuringCombat, FIELD_BOOLEAN ),
END_DATADESC();
BEGIN_DATADESC( CAI_LeadBehavior )
DEFINE_EMBEDDED( m_args ),
// m_pSink (reconnected on load)
DEFINE_FIELD( m_hSinkImplementor, FIELD_EHANDLE ),
DEFINE_FIELD( m_goal, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( m_goalyaw, FIELD_FLOAT ),
DEFINE_FIELD( m_waitpoint, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( m_waitdistance, FIELD_FLOAT ),
DEFINE_FIELD( m_leaddistance, FIELD_FLOAT ),
DEFINE_FIELD( m_retrievedistance, FIELD_FLOAT ),
DEFINE_FIELD( m_successdistance, FIELD_FLOAT ),
DEFINE_FIELD( m_weaponname, FIELD_STRING ),
DEFINE_FIELD( m_run, FIELD_BOOLEAN ),
DEFINE_FIELD( m_gagleader, FIELD_BOOLEAN ),
DEFINE_FIELD( m_hasspokenstart, FIELD_BOOLEAN ),
DEFINE_FIELD( m_hasspokenarrival, FIELD_BOOLEAN ),
DEFINE_FIELD( m_hasPausedScenes, FIELD_BOOLEAN ),
DEFINE_FIELD( m_flSpeakNextNagTime, FIELD_TIME ),
DEFINE_FIELD( m_flWeaponSafetyTimeOut, FIELD_TIME ),
DEFINE_FIELD( m_flNextLeadIdle, FIELD_TIME ),
DEFINE_FIELD( m_bInitialAheadTest, FIELD_BOOLEAN ),
DEFINE_EMBEDDED( m_MoveMonitor ),
DEFINE_EMBEDDED( m_LostTimer ),
DEFINE_EMBEDDED( m_LostLOSTimer ),
END_DATADESC();
//-----------------------------------------------------------------------------
void CAI_LeadBehavior::OnRestore()
{
CBaseEntity *pSinkImplementor = m_hSinkImplementor;
if ( pSinkImplementor )
{
m_pSink = dynamic_cast<CAI_LeadBehaviorHandler *>(pSinkImplementor);
if ( !m_pSink )
{
DevMsg( "Failed to reconnect to CAI_LeadBehaviorHandler\n" );
m_hSinkImplementor = NULL;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Draw any text overlays
// Input : Previous text offset from the top
// Output : Current text offset from the top
//-----------------------------------------------------------------------------
int CAI_LeadBehavior::DrawDebugTextOverlays( int text_offset )
{
char tempstr[ 512 ];
int offset;
offset = BaseClass::DrawDebugTextOverlays( text_offset );
if ( GetOuter()->m_debugOverlays & OVERLAY_TEXT_BIT )
{
if ( HasGoal() )
{
Q_snprintf( tempstr, sizeof(tempstr), "Goal: %s %s", m_args.pszGoal, VecToString( m_goal ) );
GetOuter()->EntityText( offset, tempstr, 0 );
offset++;
}
else
{
Q_snprintf( tempstr, sizeof(tempstr), "Goal: None" );
GetOuter()->EntityText( offset, tempstr, 0 );
offset++;
}
}
return offset;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CAI_LeadBehavior::IsNavigationUrgent( void )
{
#if defined( HL2_DLL )
if( HasGoal() && !hl2_episodic.GetBool() )
{
return (GetOuter()->Classify() == CLASS_PLAYER_ALLY_VITAL);
}
#endif
return BaseClass::IsNavigationUrgent();
}
//-------------------------------------
void CAI_LeadBehavior::LeadPlayer( const AI_LeadArgs_t &leadArgs, CAI_LeadBehaviorHandler *pSink )
{
#ifndef CSTRIKE_DLL
CAI_PlayerAlly *pOuter = dynamic_cast<CAI_PlayerAlly*>(GetOuter());
if ( pOuter && AI_IsSinglePlayer() )
{
pOuter->SetSpeechTarget( UTIL_GetLocalPlayer() );
}
#endif
if( SetGoal( leadArgs ) )
{
SetCondition( COND_PROVOKED );
Connect( pSink );
NotifyChangeBehaviorStatus();
}
else
{
DevMsg( "*** Warning! LeadPlayer() has a NULL Goal Ent\n" );
}
}
//-------------------------------------
void CAI_LeadBehavior::StopLeading( void )
{
ClearGoal();
m_pSink = NULL;
NotifyChangeBehaviorStatus();
}
//-------------------------------------
bool CAI_LeadBehavior::CanSelectSchedule()
{
if ( !AI_GetSinglePlayer() || AI_GetSinglePlayer()->IsDead() )
return false;
bool fAttacked = ( HasCondition( COND_LIGHT_DAMAGE ) || HasCondition( COND_HEAVY_DAMAGE ) );
bool fNonCombat = ( GetNpcState() == NPC_STATE_IDLE || GetNpcState() == NPC_STATE_ALERT );
return ( !fAttacked && (fNonCombat || m_args.bLeadDuringCombat) && HasGoal() );
}
//-------------------------------------
void CAI_LeadBehavior::BeginScheduleSelection()
{
SetTarget( AI_GetSinglePlayer() );
CAI_Expresser *pExpresser = GetOuter()->GetExpresser();
if ( pExpresser )
pExpresser->ClearSpokeConcept( TLK_LEAD_ARRIVAL );
}
//-------------------------------------
bool CAI_LeadBehavior::SetGoal( const AI_LeadArgs_t &args )
{
CBaseEntity *pGoalEnt;
pGoalEnt = gEntList.FindEntityByName( NULL, args.pszGoal );
if ( !pGoalEnt )
return false;
m_args = args; // @Q (toml 08-13-02): need to copy string?
m_goal = pGoalEnt->GetLocalOrigin();
m_goalyaw = (args.flags & AILF_USE_GOAL_FACING) ? pGoalEnt->GetLocalAngles().y : -1;
m_waitpoint = vec3_origin;
m_waitdistance = args.flWaitDistance;
m_leaddistance = args.flLeadDistance ? args.flLeadDistance : 64;
m_retrievedistance = args.flRetrieveDistance ? args.flRetrieveDistance : (m_leaddistance + LEAD_MIN_RETRIEVEDIST_OFFSET);
m_successdistance = args.flSuccessDistance ? args.flSuccessDistance : 0;
m_run = args.bRun;
m_gagleader = args.bGagLeader;
m_hasspokenstart = args.bDontSpeakStart;
m_hasspokenarrival = false;
m_hasPausedScenes = false;
m_flSpeakNextNagTime = 0;
m_flWeaponSafetyTimeOut = 0;
m_flNextLeadIdle = gpGlobals->curtime + 10;
m_bInitialAheadTest = true;
if ( args.pszWaitPoint && args.pszWaitPoint[0] )
{
CBaseEntity *pWaitPoint = gEntList.FindEntityByName( NULL, args.pszWaitPoint );
if ( pWaitPoint )
{
m_waitpoint = pWaitPoint->GetLocalOrigin();
}
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CAI_LeadBehavior::GetClosestPointOnRoute( const Vector &targetPos, Vector *pVecClosestPoint )
{
AI_Waypoint_t *waypoint = GetOuter()->GetNavigator()->GetPath()->GetCurWaypoint();
AI_Waypoint_t *builtwaypoints = NULL;
if ( !waypoint )
{
// We arrive here twice when lead behaviour starts:
// - When the lead behaviour is first enabled. We have no schedule. We want to know if the player is ahead of us.
// - A frame later when we've chosen to lead the player, but we still haven't built our route. We know that the
// the player isn't lagging, so it's safe to go ahead and simply say he's ahead of us. This avoids building
// the temp route twice.
if ( IsCurSchedule( SCHED_LEAD_PLAYER, false ) )
return true;
// Build a temp route to the gold and use that
builtwaypoints = GetOuter()->GetPathfinder()->BuildRoute( GetOuter()->GetAbsOrigin(), m_goal, NULL, GetOuter()->GetDefaultNavGoalTolerance(), GetOuter()->GetNavType(), true );
if ( !builtwaypoints )
return false;
GetOuter()->GetPathfinder()->UnlockRouteNodes( builtwaypoints );
waypoint = builtwaypoints;
}
// Find the nearest node to the target (going forward)
float flNearestDist2D = 999999999;
float flNearestDist = 999999999;
float flPathDist, flPathDist2D;
Vector vecNearestPoint(0, 0, 0);
Vector vecPrevPos = GetOuter()->GetAbsOrigin();
for ( ; (waypoint != NULL) ; waypoint = waypoint->GetNext() )
{
// Find the closest point on the line segment on the path
Vector vecClosest;
CalcClosestPointOnLineSegment( targetPos, vecPrevPos, waypoint->GetPos(), vecClosest );
/*
if ( builtwaypoints )
{
NDebugOverlay::Line( vecPrevPos, waypoint->GetPos(), 0,0,255,true, 10.0 );
}
*/
vecPrevPos = waypoint->GetPos();
// Find the distance between this test point and our goal point
flPathDist2D = vecClosest.AsVector2D().DistToSqr( targetPos.AsVector2D() );
if ( flPathDist2D > flNearestDist2D )
continue;
flPathDist = vecClosest.z - targetPos.z;
flPathDist *= flPathDist;
flPathDist += flPathDist2D;
if (( flPathDist2D == flNearestDist2D ) && ( flPathDist >= flNearestDist ))
continue;
flNearestDist2D = flPathDist2D;
flNearestDist = flPathDist;
vecNearestPoint = vecClosest;
}
if ( builtwaypoints )
{
//NDebugOverlay::Line( vecNearestPoint, targetPos, 0,255,0,true, 10.0 );
DeleteAll( builtwaypoints );
}
*pVecClosestPoint = vecNearestPoint;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Return true if the player is further ahead on the lead route than I am
//-----------------------------------------------------------------------------
bool CAI_LeadBehavior::PlayerIsAheadOfMe( bool bForce )
{
// Find the nearest point on our route to the player, and see if that's further
// ahead of us than our nearest point.
// If we're not leading, our route doesn't lead to the goal, so we can't use it.
// If we just started leading, go ahead and test, and we'll build a temp route.
if ( !m_bInitialAheadTest && !IsCurSchedule( SCHED_LEAD_PLAYER, false ) && !bForce )
return false;
m_bInitialAheadTest = false;
Vector vecClosestPoint;
if ( GetClosestPointOnRoute( AI_GetSinglePlayer()->GetAbsOrigin(), &vecClosestPoint ) )
{
// If the closest point is not right next to me, then
// the player is somewhere ahead of me on the route.
if ( (vecClosestPoint - GetOuter()->GetAbsOrigin()).LengthSqr() > (32*32) )
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_LeadBehavior::GatherConditions( void )
{
BaseClass::GatherConditions();
if ( HasGoal() )
{
// Fix for bad transition case (to investigate)
if ( ( WorldSpaceCenter() - m_goal ).LengthSqr() > (64*64) && IsCurSchedule( SCHED_LEAD_AWAIT_SUCCESS, false) )
{
GetOuter()->ClearSchedule( "Lead behavior - bad transition?" );
}
// We have to collect data about the person we're leading around.
CBaseEntity *pFollower = AI_GetSinglePlayer();
if( pFollower )
{
ClearCondition( COND_LEAD_FOLLOWER_VERY_CLOSE );
ClearCondition( COND_LEAD_FOLLOWER_MOVING_TOWARDS_ME );
// Check distance to the follower
float flFollowerDist = ( WorldSpaceCenter() - pFollower->WorldSpaceCenter() ).Length();
bool bLagging = flFollowerDist > (m_leaddistance*4);
if ( bLagging )
{
if ( PlayerIsAheadOfMe() )
{
bLagging = false;
}
}
// Player heading towards me?
// Only factor this in if you're not too far from them
if ( flFollowerDist < (m_leaddistance*4) )
{
Vector vecVelocity = pFollower->GetSmoothedVelocity();
if ( VectorNormalize(vecVelocity) > 50 )
{
Vector vecToPlayer = (GetAbsOrigin() - pFollower->GetAbsOrigin());
VectorNormalize( vecToPlayer );
if ( DotProduct( vecVelocity, vecToPlayer ) > 0.5 )
{
SetCondition( COND_LEAD_FOLLOWER_MOVING_TOWARDS_ME );
bLagging = false;
}
}
}
// If he's outside our lag range, consider him lagging
if ( bLagging )
{
SetCondition( COND_LEAD_FOLLOWER_LAGGING );
ClearCondition( COND_LEAD_FOLLOWER_NOT_LAGGING );
}
else
{
ClearCondition( COND_LEAD_FOLLOWER_LAGGING );
SetCondition( COND_LEAD_FOLLOWER_NOT_LAGGING );
// If he's really close, note that
if ( flFollowerDist < m_leaddistance )
{
SetCondition( COND_LEAD_FOLLOWER_VERY_CLOSE );
}
}
// To be considered not lagging, the follower must be visible, and within the lead distance
if ( GetOuter()->FVisible( pFollower ) && GetOuter()->GetSenses()->ShouldSeeEntity( pFollower ) )
{
SetCondition( COND_LEAD_HAVE_FOLLOWER_LOS );
m_LostLOSTimer.Stop();
}
else
{
ClearCondition( COND_LEAD_HAVE_FOLLOWER_LOS );
// We don't have a LOS. But if we did have LOS, don't clear it until the timer is up.
if ( m_LostLOSTimer.IsRunning() )
{
if ( m_LostLOSTimer.Expired() )
{
SetCondition( COND_LEAD_FOLLOWER_LAGGING );
ClearCondition( COND_LEAD_FOLLOWER_NOT_LAGGING );
}
}
else
{
m_LostLOSTimer.Start();
}
}
// Now we want to see if the follower is lost. Being lost means being (far away || out of LOS )
// && some time has passed. Also, lagging players are considered lost if the NPC's never delivered
// the start speech, because it means the NPC should run to the player to start the lead.
if( HasCondition( COND_LEAD_FOLLOWER_LAGGING ) )
{
if ( !m_hasspokenstart )
{
SetCondition( COND_LEAD_FOLLOWER_LOST );
}
else
{
if ( m_args.bStopScenesWhenPlayerLost )
{
// Try and stop me speaking my monolog, if I am
if ( !m_hasPausedScenes && IsRunningScriptedScene( GetOuter() ) )
{
//Msg("Stopping scenes.\n");
PauseActorsScriptedScenes( GetOuter(), false );
m_hasPausedScenes = true;
}
}
if( m_LostTimer.IsRunning() )
{
if( m_LostTimer.Expired() )
{
SetCondition( COND_LEAD_FOLLOWER_LOST );
}
}
else
{
m_LostTimer.Start();
}
}
}
else
{
// If I was speaking a monolog, resume it
if ( m_args.bStopScenesWhenPlayerLost && m_hasPausedScenes )
{
if ( IsRunningScriptedScene( GetOuter() ) )
{
//Msg("Resuming scenes.\n");
ResumeActorsScriptedScenes( GetOuter(), false );
}
m_hasPausedScenes = false;
}
m_LostTimer.Stop();
ClearCondition( COND_LEAD_FOLLOWER_LOST );
}
// Evaluate for success
// Success right now means being stationary, close to the goal, and having the player close by
if ( !( m_args.flags & AILF_NO_DEF_SUCCESS ) )
{
ClearCondition( COND_LEAD_SUCCESS );
// Check Z first, and only check 2d if we're within that
bool bWithinZ = fabs(GetLocalOrigin().z - m_goal.z) < 64;
if ( bWithinZ && (GetLocalOrigin() - m_goal).Length2D() <= 64 )
{
if ( HasCondition( COND_LEAD_FOLLOWER_VERY_CLOSE ) )
{
SetCondition( COND_LEAD_SUCCESS );
}
else if ( m_successdistance )
{
float flDistSqr = (pFollower->GetAbsOrigin() - GetLocalOrigin()).Length2DSqr();
if ( flDistSqr < (m_successdistance*m_successdistance) )
{
SetCondition( COND_LEAD_SUCCESS );
}
}
}
}
if ( m_MoveMonitor.IsMarkSet() && m_MoveMonitor.TargetMoved( pFollower ) )
SetCondition( COND_LEAD_FOLLOWER_MOVED_FROM_MARK );
else
ClearCondition( COND_LEAD_FOLLOWER_MOVED_FROM_MARK );
}
}
if( m_args.bLeadDuringCombat )
{
ClearCondition( COND_LIGHT_DAMAGE );
ClearCondition( COND_HEAVY_DAMAGE );
}
}
//-------------------------------------
int CAI_LeadBehavior::SelectSchedule()
{
if ( HasGoal() )
{
if( HasCondition(COND_LEAD_SUCCESS) )
{
return SCHED_LEAD_SUCCEED;
}
// Player's here, but does he have the weapon we want him to have?
if ( m_weaponname != NULL_STRING )
{
CBasePlayer *pFollower = AI_GetSinglePlayer();
if ( pFollower && !pFollower->Weapon_OwnsThisType( STRING(m_weaponname) ) )
{
// If the safety timeout has run out, just give the player the weapon
if ( !m_flWeaponSafetyTimeOut || (m_flWeaponSafetyTimeOut > gpGlobals->curtime) )
return SCHED_LEAD_PLAYERNEEDSWEAPON;
string_t iszItem = AllocPooledString( "weapon_bugbait" );
pFollower->GiveNamedItem( STRING(iszItem) );
}
}
// If we have a waitpoint, we want to wait at it for the player.
if( HasWaitPoint() && !PlayerIsAheadOfMe( true ) )
{
bool bKeepWaiting = true;
// If we have no wait distance, trigger as soon as the player comes in view
if ( !m_waitdistance )
{
if ( HasCondition( COND_SEE_PLAYER ) )
{
// We've spotted the player, so stop waiting
bKeepWaiting = false;
}
}
else
{
// We have to collect data about the person we're leading around.
CBaseEntity *pFollower = AI_GetSinglePlayer();
if( pFollower )
{
float flFollowerDist = ( WorldSpaceCenter() - pFollower->WorldSpaceCenter() ).Length();
if ( flFollowerDist < m_waitdistance )
{
bKeepWaiting = false;
}
}
}
// Player still not here?
if ( bKeepWaiting )
return SCHED_LEAD_WAITFORPLAYER;
// We're finished waiting
m_waitpoint = vec3_origin;
Speak( TLK_LEAD_WAITOVER );
// Don't speak the start line, because we've said
m_hasspokenstart = true;
return SCHED_WAIT_FOR_SPEAK_FINISH;
}
// If we haven't spoken our start speech, do that first
if ( !m_hasspokenstart )
{
if ( HasCondition(COND_LEAD_HAVE_FOLLOWER_LOS) && HasCondition(COND_LEAD_FOLLOWER_VERY_CLOSE) )
return SCHED_LEAD_SPEAK_START;
// We haven't spoken to him, and we still need to. Go get him.
return SCHED_LEAD_RETRIEVE;
}
if( HasCondition( COND_LEAD_FOLLOWER_LOST ) )
{
if( m_args.iRetrievePlayer )
{
// If not, we want to go get the player.
DevMsg( GetOuter(), "Follower lost. Spoke COMING_BACK.\n");
Speak( TLK_LEAD_COMINGBACK );
m_MoveMonitor.ClearMark();
// If we spoke something, wait for it to finish
if ( m_args.iComingBackWaitForSpeak && IsSpeaking() )
return SCHED_LEAD_SPEAK_THEN_RETRIEVE_PLAYER;
return SCHED_LEAD_RETRIEVE;
}
else
{
// Just stay right here and wait.
return SCHED_LEAD_WAITFORPLAYERIDLE;
}
}
if( HasCondition( COND_LEAD_FOLLOWER_LAGGING ) )
{
DevMsg( GetOuter(), "Follower lagging. Spoke CATCHUP.\n");
Speak( TLK_LEAD_CATCHUP );
return SCHED_LEAD_PAUSE;
}
else
{
// If we're at the goal, wait for the player to get here
if ( ( WorldSpaceCenter() - m_goal ).LengthSqr() < (64*64) )
return SCHED_LEAD_AWAIT_SUCCESS;
// If we were retrieving the player, speak the resume
if ( IsCurSchedule( SCHED_LEAD_RETRIEVE, false ) || IsCurSchedule( SCHED_LEAD_WAITFORPLAYERIDLE, false ) )
{
Speak( TLK_LEAD_RETRIEVE );
// If we spoke something, wait for it to finish, if the mapmakers wants us to
if ( m_args.iRetrieveWaitForSpeak && IsSpeaking() )
return SCHED_LEAD_SPEAK_THEN_LEAD_PLAYER;
}
DevMsg( GetOuter(), "Leading Follower.\n");
return SCHED_LEAD_PLAYER;
}
}
return BaseClass::SelectSchedule();
}
//-------------------------------------
int CAI_LeadBehavior::TranslateSchedule( int scheduleType )
{
bool bInCombat = (m_args.bLeadDuringCombat && GetOuter()->GetState() == NPC_STATE_COMBAT);
switch( scheduleType )
{
case SCHED_LEAD_PAUSE:
if( bInCombat )
return SCHED_LEAD_PAUSE_COMBAT;
break;
}
return BaseClass::TranslateSchedule( scheduleType );
}
//-------------------------------------
bool CAI_LeadBehavior::IsCurTaskContinuousMove()
{
const Task_t *pCurTask = GetCurTask();
if ( pCurTask && pCurTask->iTask == TASK_LEAD_MOVE_TO_RANGE )
return true;
return BaseClass::IsCurTaskContinuousMove();
}
//-------------------------------------
void CAI_LeadBehavior::StartTask( const Task_t *pTask )
{
switch ( pTask->iTask )
{
case TASK_LEAD_FACE_GOAL:
{
if ( m_goalyaw != -1 )
{
GetMotor()->SetIdealYaw( m_goalyaw );
}
TaskComplete();
break;
}
case TASK_LEAD_SUCCEED:
{
Speak( TLK_LEAD_SUCCESS );
NotifyEvent( LBE_SUCCESS );
break;
}
case TASK_LEAD_ARRIVE:
{
// Only speak the first time we arrive
if ( !m_hasspokenarrival )
{
Speak( TLK_LEAD_ARRIVAL );
NotifyEvent( LBE_ARRIVAL );
m_hasspokenarrival = true;
}
else
{
TaskComplete();
}
break;
}
case TASK_STOP_LEADING:
{
ClearGoal();
TaskComplete();
break;
}
case TASK_GET_PATH_TO_LEAD_GOAL:
{
if ( GetNavigator()->SetGoal( m_goal ) )
{
TaskComplete();
}
else
{
TaskFail("NO PATH");
}
break;
}
case TASK_LEAD_GET_PATH_TO_WAITPOINT:
{
if ( GetNavigator()->SetGoal( m_waitpoint ) )
{
TaskComplete();
}
else
{
TaskFail("NO PATH");
}
break;
}
case TASK_LEAD_WALK_PATH:
{
// If we're leading, and we're supposed to run, run instead of walking
if ( m_run &&
( IsCurSchedule( SCHED_LEAD_WAITFORPLAYER, false ) || IsCurSchedule( SCHED_LEAD_PLAYER, false ) || IsCurSchedule( SCHED_LEAD_SPEAK_THEN_LEAD_PLAYER, false )|| IsCurSchedule( SCHED_LEAD_RETRIEVE, false ) ) )
{
ChainStartTask( TASK_RUN_PATH );
}
else
{
ChainStartTask( TASK_WALK_PATH );
}
break;
}
case TASK_LEAD_WAVE_TO_PLAYER:
{
// Wave to the player if we can see him. Otherwise, just idle.
if ( HasCondition( COND_SEE_PLAYER ) )
{
Speak( TLK_LEAD_ATTRACTPLAYER );
if ( HaveSequenceForActivity(ACT_SIGNAL1) )
{
SetActivity(ACT_SIGNAL1);
}
}
else
{
SetActivity(ACT_IDLE);
}
TaskComplete();
break;
}
case TASK_LEAD_PLAYER_NEEDS_WEAPON:
{
float flAvailableTime = GetOuter()->GetExpresser()->GetSemaphoreAvailableTime( GetOuter() );
// if someone else is talking, don't speak
if ( flAvailableTime <= gpGlobals->curtime )
{
Speak( TLK_LEAD_MISSINGWEAPON );
}
SetActivity(ACT_IDLE);
TaskComplete();
break;
}
case TASK_LEAD_SPEAK_START:
{
m_hasspokenstart = true;
Speak( TLK_LEAD_START );
SetActivity(ACT_IDLE);
TaskComplete();
break;
}
case TASK_LEAD_MOVE_TO_RANGE:
{
// If we haven't spoken our start speech, move closer
if ( !m_hasspokenstart)
{
ChainStartTask( TASK_MOVE_TO_GOAL_RANGE, m_leaddistance - 24 );
}
else
{
ChainStartTask( TASK_MOVE_TO_GOAL_RANGE, m_retrievedistance );
}
break;
}
case TASK_LEAD_RETRIEVE_WAIT:
{
m_MoveMonitor.SetMark( AI_GetSinglePlayer(), 24 );
ChainStartTask( TASK_WAIT_INDEFINITE );
break;
}
case TASK_STOP_MOVING:
{
BaseClass::StartTask( pTask);
if ( IsCurSchedule( SCHED_LEAD_PAUSE, false ) && pTask->flTaskData == 1 )
{
GetNavigator()->SetArrivalDirection( GetTarget() );
}
break;
}
case TASK_WAIT_FOR_SPEAK_FINISH:
{
BaseClass::StartTask( pTask);
if( GetOuter()->GetState() == NPC_STATE_COMBAT )
{
// Don't stand around jabbering in combat.
TaskComplete();
}
// If we're not supposed to wait for the player, don't wait for speech to finish.
// Instead, just wait a wee tad, and then start moving. NPC will speak on the go.
if ( TaskIsRunning() && !m_args.iRetrievePlayer )
{
if ( gpGlobals->curtime - GetOuter()->GetTimeTaskStarted() > 0.3 )
{
TaskComplete();
}
}
break;
}
default:
BaseClass::StartTask( pTask);
}
}
//-------------------------------------
void CAI_LeadBehavior::RunTask( const Task_t *pTask )
{
switch ( pTask->iTask )
{
case TASK_LEAD_SUCCEED:
{
if ( !IsSpeaking() )
{
TaskComplete();
NotifyEvent( LBE_DONE );
}
break;
}
case TASK_LEAD_ARRIVE:
{
if ( !IsSpeaking() )
{
TaskComplete();
NotifyEvent( LBE_ARRIVAL_DONE );
}
break;
}
case TASK_LEAD_MOVE_TO_RANGE:
{
// If we haven't spoken our start speech, move closer
if ( !m_hasspokenstart)
{
ChainRunTask( TASK_MOVE_TO_GOAL_RANGE, m_leaddistance - 24 );
}
else
{
ChainRunTask( TASK_MOVE_TO_GOAL_RANGE, m_retrievedistance );
if ( !TaskIsComplete() )
{
// Transition to a walk when we get near the player
// Check Z first, and only check 2d if we're within that
Vector vecGoalPos = GetNavigator()->GetGoalPos();
float distance = fabs(vecGoalPos.z - GetLocalOrigin().z);
bool bWithinZ = false;
if ( distance < m_retrievedistance )
{
distance = ( vecGoalPos - GetLocalOrigin() ).Length2D();
bWithinZ = true;
}
if ( distance > m_retrievedistance )
{
Activity followActivity = ACT_WALK;
if ( GetOuter()->GetState() == NPC_STATE_COMBAT || ( (!bWithinZ || distance < (m_retrievedistance*4)) && GetOuter()->GetState() != NPC_STATE_COMBAT ) )
{
followActivity = ACT_RUN;
}
// Don't confuse move and shoot by resetting the activity every think
Activity curActivity = GetNavigator()->GetMovementActivity();
switch( curActivity )
{
case ACT_WALK_AIM: curActivity = ACT_WALK; break;
case ACT_RUN_AIM: curActivity = ACT_RUN; break;
}
if ( curActivity != followActivity )
{
GetNavigator()->SetMovementActivity(followActivity);
}
GetNavigator()->SetArrivalDirection( GetOuter()->GetTarget() );
}
}
}
break;
}
case TASK_LEAD_RETRIEVE_WAIT:
{
ChainRunTask( TASK_WAIT_INDEFINITE );
break;
}
case TASK_LEAD_WALK_PATH:
{
// If we're leading, and we're supposed to run, run instead of walking
if ( m_run &&
( IsCurSchedule( SCHED_LEAD_WAITFORPLAYER, false ) || IsCurSchedule( SCHED_LEAD_PLAYER, false ) || IsCurSchedule( SCHED_LEAD_SPEAK_THEN_LEAD_PLAYER, false )|| IsCurSchedule( SCHED_LEAD_RETRIEVE, false ) ) )
{
ChainRunTask( TASK_RUN_PATH );
}
else
{
ChainRunTask( TASK_WALK_PATH );
}
// While we're walking
if ( TaskIsRunning() && IsCurSchedule( SCHED_LEAD_PLAYER, false ) )
{
// If we're not speaking, and we haven't tried for a while, try to speak lead idle
if ( m_flNextLeadIdle < gpGlobals->curtime && !IsSpeaking() )
{
m_flNextLeadIdle = gpGlobals->curtime + RandomFloat( 10,15 );
if ( !m_args.iRetrievePlayer && HasCondition( COND_LEAD_FOLLOWER_LOST ) && HasCondition(COND_SEE_PLAYER) )
{
Speak( TLK_LEAD_COMINGBACK );
}
else
{
Speak( TLK_LEAD_IDLE );
}
}
}
break;
}
default:
BaseClass::RunTask( pTask);
}
}
//-------------------------------------
bool CAI_LeadBehavior::Speak( AIConcept_t concept )
{
CAI_Expresser *pExpresser = GetOuter()->GetExpresser();
if ( !pExpresser )
return false;
// If the leader is gagged, don't speak any lead speech
if ( m_gagleader )
return false;
// If we haven't said the start speech, don't nag
bool bNag = ( FStrEq(concept,TLK_LEAD_COMINGBACK) || FStrEq(concept, TLK_LEAD_CATCHUP) || FStrEq(concept, TLK_LEAD_RETRIEVE) );
if ( !m_hasspokenstart && bNag )
return false;
if ( hl2_episodic.GetBool() )
{
// If we're a player ally, only speak the concept if we're allowed to.
// This allows the response rules to control it better (i.e. handles respeakdelay)
// We ignore nag timers for this, because the response rules will control refire rates.
CAI_PlayerAlly *pAlly = dynamic_cast<CAI_PlayerAlly*>(GetOuter());
if ( pAlly )
return pAlly->SpeakIfAllowed( concept, GetConceptModifiers( concept ) );
}
// Don't spam Nags
if ( bNag )
{
if ( m_flSpeakNextNagTime > gpGlobals->curtime )
{
DevMsg( GetOuter(), "Leader didn't speak due to Nag timer.\n");
return false;
}
}
if ( pExpresser->Speak( concept, GetConceptModifiers( concept ) ) )
{
m_flSpeakNextNagTime = gpGlobals->curtime + LEAD_NAG_TIME;
return true;
}
return false;
}
//-------------------------------------
bool CAI_LeadBehavior::IsSpeaking()
{
CAI_Expresser *pExpresser = GetOuter()->GetExpresser();
if ( !pExpresser )
return false;
return pExpresser->IsSpeaking();
}
//-------------------------------------
bool CAI_LeadBehavior::Connect( CAI_LeadBehaviorHandler *pSink )
{
m_pSink = pSink;
m_hSinkImplementor = dynamic_cast<CBaseEntity *>(pSink);
if ( m_hSinkImplementor == NULL )
DevMsg( 2, "Note: CAI_LeadBehaviorHandler connected to a sink that isn't an entity. Manual fixup on load will be necessary\n" );
return true;
}
//-------------------------------------
bool CAI_LeadBehavior::Disconnect( CAI_LeadBehaviorHandler *pSink )
{
Assert( pSink == m_pSink );
m_pSink = NULL;
m_hSinkImplementor = NULL;
return true;
}
//-------------------------------------
AI_BEGIN_CUSTOM_SCHEDULE_PROVIDER( CAI_LeadBehavior )
DECLARE_CONDITION( COND_LEAD_FOLLOWER_LOST )
DECLARE_CONDITION( COND_LEAD_FOLLOWER_LAGGING )
DECLARE_CONDITION( COND_LEAD_FOLLOWER_NOT_LAGGING )
DECLARE_CONDITION( COND_LEAD_FOLLOWER_VERY_CLOSE )
DECLARE_CONDITION( COND_LEAD_SUCCESS )
DECLARE_CONDITION( COND_LEAD_HAVE_FOLLOWER_LOS )
DECLARE_CONDITION( COND_LEAD_FOLLOWER_MOVED_FROM_MARK )
DECLARE_CONDITION( COND_LEAD_FOLLOWER_MOVING_TOWARDS_ME )
//---------------------------------
//
// Lead
//
DECLARE_TASK( TASK_GET_PATH_TO_LEAD_GOAL )
DECLARE_TASK( TASK_STOP_LEADING )
DECLARE_TASK( TASK_LEAD_ARRIVE )
DECLARE_TASK( TASK_LEAD_SUCCEED )
DECLARE_TASK( TASK_LEAD_FACE_GOAL )
DECLARE_TASK( TASK_LEAD_GET_PATH_TO_WAITPOINT )
DECLARE_TASK( TASK_LEAD_WAVE_TO_PLAYER )
DECLARE_TASK( TASK_LEAD_PLAYER_NEEDS_WEAPON )
DECLARE_TASK( TASK_LEAD_MOVE_TO_RANGE )
DECLARE_TASK( TASK_LEAD_SPEAK_START )
DECLARE_TASK( TASK_LEAD_RETRIEVE_WAIT )
DECLARE_TASK( TASK_LEAD_WALK_PATH )
DEFINE_SCHEDULE
(
SCHED_LEAD_RETRIEVE,
" Tasks"
" TASK_GET_PATH_TO_PLAYER 0"
" TASK_LEAD_MOVE_TO_RANGE 0"
" TASK_STOP_MOVING 0"
" TASK_WAIT_FOR_SPEAK_FINISH 1"
" TASK_SET_SCHEDULE SCHEDULE:SCHED_LEAD_RETRIEVE_WAIT"
" "
" Interrupts"
" COND_LEAD_FOLLOWER_VERY_CLOSE"
" COND_LEAD_FOLLOWER_MOVING_TOWARDS_ME"
" COND_LIGHT_DAMAGE"
" COND_NEW_ENEMY"
" COND_HEAR_DANGER"
)
//-------------------------------------
DEFINE_SCHEDULE
(
SCHED_LEAD_SPEAK_THEN_RETRIEVE_PLAYER,
" Tasks"
" TASK_WAIT_FOR_SPEAK_FINISH 1"
" TASK_SET_SCHEDULE SCHEDULE:SCHED_LEAD_RETRIEVE"
" "
" Interrupts"
" COND_LEAD_FOLLOWER_VERY_CLOSE"
" COND_LEAD_FOLLOWER_MOVING_TOWARDS_ME"
" COND_LIGHT_DAMAGE"
" COND_NEW_ENEMY"
" COND_HEAR_DANGER"
)
//-------------------------------------
DEFINE_SCHEDULE
(
SCHED_LEAD_RETRIEVE_WAIT,
" Tasks"
" TASK_LEAD_RETRIEVE_WAIT 0"
" "
" Interrupts"
" COND_LEAD_FOLLOWER_LOST"
" COND_LEAD_FOLLOWER_LAGGING"
" COND_LEAD_FOLLOWER_VERY_CLOSE"
" COND_LEAD_FOLLOWER_MOVING_TOWARDS_ME"
" COND_LEAD_FOLLOWER_MOVED_FROM_MARK"
" COND_LIGHT_DAMAGE"
" COND_NEW_ENEMY"
" COND_HEAR_DANGER"
)
//---------------------------------
DEFINE_SCHEDULE
(
SCHED_LEAD_PLAYER,
" Tasks"
" TASK_WAIT_FOR_SPEAK_FINISH 1"
" TASK_GET_PATH_TO_LEAD_GOAL 0"
" TASK_LEAD_WALK_PATH 0"
" TASK_WAIT_FOR_MOVEMENT 0"
" TASK_STOP_MOVING 0"
""
" Interrupts"
" COND_LEAD_FOLLOWER_LOST"
" COND_LEAD_FOLLOWER_LAGGING"
" COND_LIGHT_DAMAGE"
" COND_NEW_ENEMY"
" COND_HEAR_DANGER"
)
//---------------------------------
DEFINE_SCHEDULE
(
SCHED_LEAD_AWAIT_SUCCESS,
" Tasks"
" TASK_LEAD_FACE_GOAL 0"
" TASK_FACE_IDEAL 0"
" TASK_LEAD_ARRIVE 0"
" TASK_WAIT_INDEFINITE 0"
""
" Interrupts"
" COND_LEAD_FOLLOWER_LOST"
" COND_LEAD_FOLLOWER_LAGGING"
" COND_LEAD_SUCCESS"
" COND_LIGHT_DAMAGE"
" COND_NEW_ENEMY"
" COND_HEAR_DANGER"
)
//---------------------------------
DEFINE_SCHEDULE
(
SCHED_LEAD_SUCCEED,
" Tasks"
" TASK_LEAD_SUCCEED 0"
" TASK_STOP_LEADING 0"
""
)
//---------------------------------
// This is the schedule Odell uses to pause the tour momentarily
// if the player lags behind. If the player shows up in a
// couple of seconds, the tour will resume. Otherwise, Odell
// moves to retrieve.
//---------------------------------
DEFINE_SCHEDULE
(
SCHED_LEAD_PAUSE,
" Tasks"
" TASK_STOP_MOVING 1"
" TASK_FACE_TARGET 0"
" TASK_WAIT 5"
" TASK_WAIT_RANDOM 5"
" TASK_SET_SCHEDULE SCHEDULE:SCHED_LEAD_RETRIEVE"
""
" Interrupts"
" COND_LEAD_FOLLOWER_VERY_CLOSE"
" COND_LEAD_FOLLOWER_MOVING_TOWARDS_ME"
" COND_LEAD_FOLLOWER_NOT_LAGGING"
" COND_LEAD_FOLLOWER_LOST"
" COND_LIGHT_DAMAGE"
" COND_NEW_ENEMY"
" COND_HEAR_DANGER"
)
DEFINE_SCHEDULE
(
SCHED_LEAD_PAUSE_COMBAT,
" Tasks"
" TASK_STOP_MOVING 1"
" TASK_FACE_TARGET 0"
" TASK_WAIT 1"
" TASK_SET_SCHEDULE SCHEDULE:SCHED_LEAD_RETRIEVE"
""
" Interrupts"
" COND_LEAD_FOLLOWER_VERY_CLOSE"
" COND_LEAD_FOLLOWER_MOVING_TOWARDS_ME"
" COND_LEAD_FOLLOWER_NOT_LAGGING"
" COND_LEAD_FOLLOWER_LOST"
" COND_HEAR_DANGER"
)
//---------------------------------
DEFINE_SCHEDULE
(
SCHED_LEAD_WAITFORPLAYER,
" Tasks"
" TASK_LEAD_GET_PATH_TO_WAITPOINT 0"
" TASK_LEAD_WALK_PATH 0"
" TASK_WAIT_FOR_MOVEMENT 0"
" TASK_STOP_MOVING 0"
" TASK_WAIT 0.5"
" TASK_FACE_TARGET 0"
" TASK_LEAD_WAVE_TO_PLAYER 0"
" TASK_WAIT 5.0"
" "
" Interrupts"
" COND_LEAD_FOLLOWER_VERY_CLOSE"
" COND_LIGHT_DAMAGE"
" COND_NEW_ENEMY"
" COND_HEAR_DANGER"
)
//---------------------------------
DEFINE_SCHEDULE
(
SCHED_LEAD_WAITFORPLAYERIDLE,
" Tasks"
" TASK_STOP_MOVING 0"
" TASK_WAIT 0.5"
" TASK_FACE_TARGET 0"
" TASK_PLAY_SEQUENCE ACTIVITY:ACT_IDLE"
" TASK_WAIT 2"
" "
" Interrupts"
" COND_LEAD_FOLLOWER_VERY_CLOSE"
" COND_LIGHT_DAMAGE"
" COND_NEW_ENEMY"
" COND_HEAR_DANGER"
)
//---------------------------------
DEFINE_SCHEDULE
(
SCHED_LEAD_PLAYERNEEDSWEAPON,
" Tasks"
" TASK_FACE_PLAYER 0"
" TASK_LEAD_PLAYER_NEEDS_WEAPON 0"
" TASK_WAIT_FOR_SPEAK_FINISH 1"
" TASK_WAIT 8"
" "
" Interrupts"
)
//---------------------------------
DEFINE_SCHEDULE
(
SCHED_LEAD_SPEAK_START,
" Tasks"
" TASK_LEAD_SPEAK_START 0"
" TASK_WAIT_FOR_SPEAK_FINISH 1"
""
" Interrupts"
)
//---------------------------------
DEFINE_SCHEDULE
(
SCHED_LEAD_SPEAK_THEN_LEAD_PLAYER,
" Tasks"
" TASK_STOP_MOVING 0"
" TASK_WAIT_FOR_SPEAK_FINISH 1"
" TASK_SET_SCHEDULE SCHEDULE:SCHED_LEAD_PLAYER"
""
" Interrupts"
" COND_LEAD_FOLLOWER_LOST"
" COND_LEAD_FOLLOWER_LAGGING"
" COND_LIGHT_DAMAGE"
" COND_NEW_ENEMY"
" COND_HEAR_DANGER"
)
AI_END_CUSTOM_SCHEDULE_PROVIDER()
//-----------------------------------------------------------------------------
//
// Purpose: A level tool to control the lead behavior. Use is not required
// in order to use behavior.
//
class CAI_LeadGoal : public CAI_GoalEntity,
public CAI_LeadBehaviorHandler
{
DECLARE_CLASS( CAI_LeadGoal, CAI_GoalEntity );
public:
CAI_LeadGoal()
: m_fArrived( false )
{
// These fields got added after existing levels shipped, so we set
// the default values here in the constructor.
m_iRetrievePlayer = 1;
m_iRetrieveWaitForSpeak = 0;
m_iComingBackWaitForSpeak = 0;
m_bStopScenesWhenPlayerLost = false;
m_bDontSpeakStart = false;
m_bLeadDuringCombat = false;
m_bGagLeader = false;
}
CAI_LeadBehavior *GetLeadBehavior();
virtual const char *GetConceptModifiers( const char *pszConcept );
virtual void InputActivate( inputdata_t &inputdata );
virtual void InputDeactivate( inputdata_t &inputdata );
DECLARE_DATADESC();
private:
virtual void OnEvent( int event );
void InputSetSuccess( inputdata_t &inputdata );
void InputSetFailure( inputdata_t &inputdata );
bool m_fArrived; // @TODO (toml 08-16-02): move arrived tracking onto behavior
float m_flWaitDistance;
float m_flLeadDistance;
float m_flRetrieveDistance;
float m_flSuccessDistance;
bool m_bRun;
int m_iRetrievePlayer;
int m_iRetrieveWaitForSpeak;
int m_iComingBackWaitForSpeak;
bool m_bStopScenesWhenPlayerLost;
bool m_bDontSpeakStart;
bool m_bLeadDuringCombat;
bool m_bGagLeader;
string_t m_iszWaitPointName;
string_t m_iszStartConceptModifier;
string_t m_iszAttractPlayerConceptModifier;
string_t m_iszWaitOverConceptModifier;
string_t m_iszArrivalConceptModifier;
string_t m_iszPostArrivalConceptModifier;
string_t m_iszSuccessConceptModifier;
string_t m_iszFailureConceptModifier;
string_t m_iszRetrieveConceptModifier;
string_t m_iszComingBackConceptModifier;
// Output handlers
COutputEvent m_OnArrival;
COutputEvent m_OnArrivalDone;
COutputEvent m_OnSuccess;
COutputEvent m_OnFailure;
COutputEvent m_OnDone;
};
//-----------------------------------------------------------------------------
//
// CAI_LeadGoal implementation
//
LINK_ENTITY_TO_CLASS( ai_goal_lead, CAI_LeadGoal );
BEGIN_DATADESC( CAI_LeadGoal )
DEFINE_FIELD( m_fArrived, FIELD_BOOLEAN ),
DEFINE_KEYFIELD(m_flWaitDistance, FIELD_FLOAT, "WaitDistance"),
DEFINE_KEYFIELD(m_iszWaitPointName, FIELD_STRING, "WaitPointName"),
DEFINE_KEYFIELD(m_flLeadDistance, FIELD_FLOAT, "LeadDistance"),
DEFINE_KEYFIELD(m_flRetrieveDistance, FIELD_FLOAT, "RetrieveDistance"),
DEFINE_KEYFIELD(m_flSuccessDistance, FIELD_FLOAT, "SuccessDistance"),
DEFINE_KEYFIELD(m_bRun, FIELD_BOOLEAN, "Run"),
DEFINE_KEYFIELD(m_iRetrievePlayer, FIELD_INTEGER, "Retrieve"),
DEFINE_KEYFIELD(m_iRetrieveWaitForSpeak, FIELD_INTEGER, "RetrieveWaitForSpeak"),
DEFINE_KEYFIELD(m_iComingBackWaitForSpeak, FIELD_INTEGER, "ComingBackWaitForSpeak"),
DEFINE_KEYFIELD(m_bStopScenesWhenPlayerLost, FIELD_BOOLEAN, "StopScenes"),
DEFINE_KEYFIELD(m_bDontSpeakStart, FIELD_BOOLEAN, "DontSpeakStart"),
DEFINE_KEYFIELD(m_bLeadDuringCombat, FIELD_BOOLEAN, "LeadDuringCombat"),
DEFINE_KEYFIELD(m_bGagLeader, FIELD_BOOLEAN, "GagLeader"),
DEFINE_KEYFIELD(m_iszStartConceptModifier, FIELD_STRING, "StartConceptModifier"),
DEFINE_KEYFIELD(m_iszAttractPlayerConceptModifier, FIELD_STRING, "AttractPlayerConceptModifier"),
DEFINE_KEYFIELD(m_iszWaitOverConceptModifier, FIELD_STRING, "WaitOverConceptModifier"),
DEFINE_KEYFIELD(m_iszArrivalConceptModifier, FIELD_STRING, "ArrivalConceptModifier"),
DEFINE_KEYFIELD(m_iszPostArrivalConceptModifier, FIELD_STRING, "PostArrivalConceptModifier"),
DEFINE_KEYFIELD(m_iszSuccessConceptModifier, FIELD_STRING, "SuccessConceptModifier"),
DEFINE_KEYFIELD(m_iszFailureConceptModifier, FIELD_STRING, "FailureConceptModifier"),
DEFINE_KEYFIELD(m_iszRetrieveConceptModifier, FIELD_STRING, "RetrieveConceptModifier"),
DEFINE_KEYFIELD(m_iszComingBackConceptModifier, FIELD_STRING, "ComingBackConceptModifier"),
DEFINE_OUTPUT( m_OnSuccess, "OnSuccess" ),
DEFINE_OUTPUT( m_OnArrival, "OnArrival" ),
DEFINE_OUTPUT( m_OnArrivalDone, "OnArrivalDone" ),
DEFINE_OUTPUT( m_OnFailure, "OnFailure" ),
DEFINE_OUTPUT( m_OnDone, "OnDone" ),
// Inputs
DEFINE_INPUTFUNC( FIELD_VOID, "SetSuccess", InputSetSuccess ),
DEFINE_INPUTFUNC( FIELD_VOID, "SetFailure", InputSetFailure ),
END_DATADESC()
//-----------------------------------------------------------------------------
CAI_LeadBehavior *CAI_LeadGoal::GetLeadBehavior()
{
CAI_BaseNPC *pActor = GetActor();
if ( !pActor )
return NULL;
CAI_LeadBehavior *pBehavior;
if ( !pActor->GetBehavior( &pBehavior ) )
{
return NULL;
}
return pBehavior;
}
//-----------------------------------------------------------------------------
void CAI_LeadGoal::InputSetSuccess( inputdata_t &inputdata )
{
CAI_LeadBehavior *pBehavior = GetLeadBehavior();
if ( !pBehavior )
return;
// @TODO (toml 02-14-03): Hackly!
pBehavior->SetCondition( CAI_LeadBehavior::COND_LEAD_SUCCESS);
}
//-----------------------------------------------------------------------------
void CAI_LeadGoal::InputSetFailure( inputdata_t &inputdata )
{
DevMsg( "SetFailure unimplemented\n" );
}
//-----------------------------------------------------------------------------
void CAI_LeadGoal::InputActivate( inputdata_t &inputdata )
{
BaseClass::InputActivate( inputdata );
CAI_LeadBehavior *pBehavior = GetLeadBehavior();
if ( !pBehavior )
{
DevMsg( "Lead goal entity activated for an NPC that doesn't have the lead behavior\n" );
return;
}
#ifdef HL2_EPISODIC
if ( (m_flLeadDistance*4) < m_flRetrieveDistance )
{
Warning("ai_goal_lead '%s': lead distance (%.2f) * 4 is < retrieve distance (%.2f). This will make the NPC act stupid. Either reduce the retrieve distance, or increase the lead distance.\n", GetDebugName(), m_flLeadDistance, m_flRetrieveDistance );
}
#endif
if ( m_flRetrieveDistance < (m_flLeadDistance + LEAD_MIN_RETRIEVEDIST_OFFSET) )
{
#ifdef HL2_EPISODIC
Warning("ai_goal_lead '%s': retrieve distance (%.2f) < lead distance (%.2f) + %d. Retrieve distance should be at least %d greater than the lead distance, or NPC will ping-pong while retrieving.\n", GetDebugName(), m_flRetrieveDistance, m_flLeadDistance, LEAD_MIN_RETRIEVEDIST_OFFSET, LEAD_MIN_RETRIEVEDIST_OFFSET );
#endif
m_flRetrieveDistance = m_flLeadDistance + LEAD_MIN_RETRIEVEDIST_OFFSET;
}
AI_LeadArgs_t leadArgs = {
GetGoalEntityName(),
STRING(m_iszWaitPointName),
(unsigned)m_spawnflags,
m_flWaitDistance,
m_flLeadDistance,
m_flRetrieveDistance,
m_flSuccessDistance,
m_bRun,
m_iRetrievePlayer,
m_iRetrieveWaitForSpeak,
m_iComingBackWaitForSpeak,
m_bStopScenesWhenPlayerLost,
m_bDontSpeakStart,
m_bLeadDuringCombat,
m_bGagLeader,
};
pBehavior->LeadPlayer( leadArgs, this );
}
//-----------------------------------------------------------------------------
void CAI_LeadGoal::InputDeactivate( inputdata_t &inputdata )
{
BaseClass::InputDeactivate( inputdata );
CAI_LeadBehavior *pBehavior = GetLeadBehavior();
if ( !pBehavior )
return;
pBehavior->StopLeading();
}
//-----------------------------------------------------------------------------
void CAI_LeadGoal::OnEvent( int event )
{
COutputEvent *pOutputEvent = NULL;
switch ( event )
{
case LBE_ARRIVAL: pOutputEvent = &m_OnArrival; break;
case LBE_ARRIVAL_DONE: pOutputEvent = &m_OnArrivalDone; break;
case LBE_SUCCESS: pOutputEvent = &m_OnSuccess; break;
case LBE_FAILURE: pOutputEvent = &m_OnFailure; break;
case LBE_DONE: pOutputEvent = &m_OnDone; break;
}
// @TODO (toml 08-16-02): move arrived tracking onto behavior
if ( event == LBE_ARRIVAL )
m_fArrived = true;
if ( pOutputEvent )
pOutputEvent->FireOutput( this, this );
}
//-----------------------------------------------------------------------------
const char *CAI_LeadGoal::GetConceptModifiers( const char *pszConcept )
{
if ( m_iszStartConceptModifier != NULL_STRING && *STRING(m_iszStartConceptModifier) && strcmp( pszConcept, TLK_LEAD_START) == 0 )
return STRING( m_iszStartConceptModifier );
if ( m_iszAttractPlayerConceptModifier != NULL_STRING && *STRING(m_iszAttractPlayerConceptModifier) && strcmp( pszConcept, TLK_LEAD_ATTRACTPLAYER) == 0 )
return STRING( m_iszAttractPlayerConceptModifier );
if ( m_iszWaitOverConceptModifier != NULL_STRING && *STRING(m_iszWaitOverConceptModifier) && strcmp( pszConcept, TLK_LEAD_WAITOVER) == 0 )
return STRING( m_iszWaitOverConceptModifier );
if ( m_iszArrivalConceptModifier != NULL_STRING && *STRING(m_iszArrivalConceptModifier) && strcmp( pszConcept, TLK_LEAD_ARRIVAL) == 0 )
return STRING( m_iszArrivalConceptModifier );
if ( m_iszSuccessConceptModifier != NULL_STRING && *STRING(m_iszSuccessConceptModifier) && strcmp( pszConcept, TLK_LEAD_SUCCESS) == 0 )
return STRING( m_iszSuccessConceptModifier );
if (m_iszFailureConceptModifier != NULL_STRING && *STRING(m_iszFailureConceptModifier) && strcmp( pszConcept, TLK_LEAD_FAILURE) == 0 )
return STRING( m_iszFailureConceptModifier );
if (m_iszRetrieveConceptModifier != NULL_STRING && *STRING(m_iszRetrieveConceptModifier) && strcmp( pszConcept, TLK_LEAD_RETRIEVE) == 0 )
return STRING( m_iszRetrieveConceptModifier );
if (m_iszComingBackConceptModifier != NULL_STRING && *STRING(m_iszComingBackConceptModifier) && strcmp( pszConcept, TLK_LEAD_COMINGBACK) == 0 )
return STRING( m_iszComingBackConceptModifier );
if ( m_fArrived && m_iszPostArrivalConceptModifier != NULL_STRING && *STRING(m_iszPostArrivalConceptModifier) )
return STRING( m_iszPostArrivalConceptModifier );
return NULL;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//
// Purpose: A custom lead goal that waits until the player has a weapon.
//
class CAI_LeadGoal_Weapon : public CAI_LeadGoal
{
DECLARE_CLASS( CAI_LeadGoal_Weapon, CAI_LeadGoal );
public:
virtual const char *GetConceptModifiers( const char *pszConcept );
virtual void InputActivate( inputdata_t &inputdata );
private:
string_t m_iszWeaponName;
string_t m_iszMissingWeaponConceptModifier;
DECLARE_DATADESC();
};
//-----------------------------------------------------------------------------
//
// CAI_LeadGoal_Weapon implementation
//
LINK_ENTITY_TO_CLASS( ai_goal_lead_weapon, CAI_LeadGoal_Weapon );
BEGIN_DATADESC( CAI_LeadGoal_Weapon )
DEFINE_KEYFIELD( m_iszWeaponName, FIELD_STRING, "WeaponName"),
DEFINE_KEYFIELD( m_iszMissingWeaponConceptModifier, FIELD_STRING, "MissingWeaponConceptModifier"),
END_DATADESC()
//-----------------------------------------------------------------------------
const char *CAI_LeadGoal_Weapon::GetConceptModifiers( const char *pszConcept )
{
if ( m_iszMissingWeaponConceptModifier != NULL_STRING && *STRING(m_iszMissingWeaponConceptModifier) && strcmp( pszConcept, TLK_LEAD_MISSINGWEAPON) == 0 )
return STRING( m_iszMissingWeaponConceptModifier );
return BaseClass::GetConceptModifiers( pszConcept );
}
//-----------------------------------------------------------------------------
void CAI_LeadGoal_Weapon::InputActivate( inputdata_t &inputdata )
{
BaseClass::InputActivate( inputdata );
CAI_LeadBehavior *pBehavior = GetLeadBehavior();
if ( pBehavior )
{
pBehavior->SetWaitForWeapon( m_iszWeaponName );
}
}