//====== Copyright 1996-2005, Valve Corporation, All rights reserved. =======
//
// Purpose: Companion NPCs riding in cars
//
//=============================================================================
#include "cbase.h"
#include "ai_speech.h"
#include "ai_pathfinder.h"
#include "ai_waypoint.h"
#include "ai_navigator.h"
#include "ai_navgoaltype.h"
#include "ai_memory.h"
#include "ai_behavior_passenger_companion.h"
#include "ai_squadslot.h"
#include "npc_playercompanion.h"
#include "ai_route.h"
#include "saverestore_utlvector.h"
#define TLK_PASSENGER_WARN_COLLISION "TLK_PASSENGER_WARN_COLLISION"
#define TLK_PASSENGER_IMPACT "TLK_PASSENGER_IMPACT"
#define TLK_PASSENGER_OVERTURNED "TLK_PASSENGER_OVERTURNED"
#define TLK_PASSENGER_REQUEST_UPRIGHT "TLK_PASSENGER_REQUEST_UPRIGHT"
#define PASSENGER_NEAR_VEHICLE_THRESHOLD 64.0f
#define MIN_OVERTURNED_DURATION 1.0f // seconds
#define MIN_FAILED_EXIT_ATTEMPTS 2
#define MIN_OVERTURNED_WARN_DURATION 4.0f // seconds
ConVar passenger_impact_response_threshold( "passenger_impact_response_threshold", "-500.0" );
ConVar passenger_collision_response_threshold( "passenger_collision_response_threshold", "500.0" );
extern ConVar passenger_debug_transition;
// Custom activities
Activity ACT_PASSENGER_IDLE_AIM;
Activity ACT_PASSENGER_RELOAD;
Activity ACT_PASSENGER_OVERTURNED;
Activity ACT_PASSENGER_IMPACT;
Activity ACT_PASSENGER_IMPACT_WEAPON;
Activity ACT_PASSENGER_POINT;
Activity ACT_PASSENGER_POINT_BEHIND;
Activity ACT_PASSENGER_IDLE_READY;
BEGIN_DATADESC( CAI_PassengerBehaviorCompanion )
DEFINE_EMBEDDED( m_vehicleState ),
DEFINE_EMBEDDED( m_VehicleMonitor ),
DEFINE_UTLVECTOR( m_FailedEntryPositions, FIELD_EMBEDDED ),
DEFINE_FIELD( m_flOverturnedDuration, FIELD_FLOAT ),
DEFINE_FIELD( m_flUnseenDuration, FIELD_FLOAT ),
DEFINE_FIELD( m_nExitAttempts, FIELD_INTEGER ),
DEFINE_FIELD( m_flNextOverturnWarning, FIELD_TIME ),
END_DATADESC();
BEGIN_SIMPLE_DATADESC( FailPosition_t )
DEFINE_FIELD( vecPosition, FIELD_VECTOR ),
DEFINE_FIELD( flTime, FIELD_TIME ),
END_DATADESC();
CAI_PassengerBehaviorCompanion::CAI_PassengerBehaviorCompanion( void ) :
m_flUnseenDuration( 0.0f ),
m_flNextOverturnWarning( 0.0f ),
m_flOverturnedDuration( 0.0f ),
m_nExitAttempts( 0 )
{
memset( &m_vehicleState, 0, sizeof( m_vehicleState ) );
m_VehicleMonitor.ClearMark();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : activity -
// Output : int
//-----------------------------------------------------------------------------
Activity CAI_PassengerBehaviorCompanion::NPC_TranslateActivity( Activity activity )
{
Activity newActivity = BaseClass::NPC_TranslateActivity( activity );
// Handle animations from inside the vehicle
if ( GetPassengerState() == PASSENGER_STATE_INSIDE )
{
// Make sure idles are always vehicle idles
if ( newActivity == ACT_IDLE )
{
newActivity = (Activity) ACT_PASSENGER_IDLE;
}
// Alter idle depending on the vehicle's state
if ( newActivity == ACT_PASSENGER_IDLE )
{
// Always play the overturned animation
if ( m_vehicleState.m_bWasOverturned )
return ACT_PASSENGER_OVERTURNED;
// If we have an enemy and a gun, aim
if ( GetEnemy() != NULL && HasCondition( COND_SEE_ENEMY ) && GetOuter()->GetActiveWeapon() )
return ACT_PASSENGER_IDLE_AIM;
CNPC_PlayerCompanion *pCompanion = dynamic_cast<CNPC_PlayerCompanion *>(GetOuter());
if ( pCompanion != NULL && pCompanion->GetReadinessLevel() >= AIRL_STIMULATED )
return ACT_PASSENGER_IDLE_READY;
}
// Override reloads
if ( newActivity == ACT_RELOAD )
return ACT_PASSENGER_RELOAD;
// Override range attacks
if ( newActivity == ACT_RANGE_ATTACK1 )
return (Activity) ACT_PASSENGER_RANGE_ATTACK1;
// FIXME: Translation is never called for scripted events
// Do special logic in points
/*
if ( newActivity == ACT_PASSENGER_POINT )
{
// See if this is behind us
float curYaw = GetOuter()->GetPoseParameter( "aim_yaw" );
if ( fabs( curYaw ) > 180.0f )
return ACT_PASSENGER_POINT_BEHIND;
}
*/
}
return newActivity;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the speed the vehicle is moving at
// Output : units per second
//-----------------------------------------------------------------------------
float CAI_PassengerBehaviorCompanion::GetVehicleSpeed( void )
{
if ( m_hVehicle == NULL )
{
Assert(0);
return -1.0f;
}
Vector vecVelocity;
m_hVehicle->GetVelocity( &vecVelocity, NULL );
// Get our speed
return vecVelocity.Length();
}
//-----------------------------------------------------------------------------
// Purpose: Detect oncoming collisions
//-----------------------------------------------------------------------------
void CAI_PassengerBehaviorCompanion::GatherVehicleCollisionConditions( const Vector &localVelocity )
{
// Look for walls in front of us
if ( localVelocity.y > passenger_collision_response_threshold.GetFloat() )
{
// Detect an upcoming collision
Vector vForward;
m_hVehicle->GetVectors( &vForward, NULL, NULL );
// Use a smaller bounding box to make it detect mostly head-on impacts
Vector mins, maxs;
mins.Init( -16, -16, 32 );
maxs.Init( 16, 16, 64 );
// Look 3/4 a second into the future
float dt = 0.75f;
float distance = localVelocity.y * dt;
// Trace ahead of us to see what's there
trace_t tr;
UTIL_TraceHull( m_hVehicle->GetAbsOrigin(), m_hVehicle->GetAbsOrigin() + ( vForward * distance ), mins, maxs, MASK_SOLID_BRUSHONLY, m_hVehicle, COLLISION_GROUP_NONE, &tr );
if ( tr.DidHit() )
{
// We need to see how "head-on" to the surface we are
float impactDot = DotProduct( tr.plane.normal, vForward );
// Don't warn over grazing blows or slopes
if ( impactDot < -0.9f && tr.plane.normal.z < 0.75f )
{
// Only warn if it's not too soon to do it again
if ( m_vehicleState.m_flNextWarningTime < gpGlobals->curtime )
{
// TODO: Turn this into a condition so that we can interrupt other schedules
GetOuter()->GetExpresser()->Speak( TLK_PASSENGER_WARN_COLLISION );
m_vehicleState.m_flNextWarningTime = gpGlobals->curtime + 5.0f;
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Gather conditions we can comment on or react to while riding in the vehicle
//-----------------------------------------------------------------------------
void CAI_PassengerBehaviorCompanion::GatherVehicleStateConditions( void )
{
if ( m_hVehicle == NULL )
return;
// Get the vehicle's boost state
if ( m_hVehicle->m_nBoostTimeLeft < 100.0f )
{
if ( m_vehicleState.m_bWasBoosting == false )
{
m_vehicleState.m_bWasBoosting = true;
}
}
else
{
m_vehicleState.m_bWasBoosting = false;
}
Vector localVelocity;
GetLocalVehicleVelocity( &localVelocity );
// Get our speed
float flSpeedSqr = localVelocity.LengthSqr();
// See if we've crossed over the threshold between movement and... stillness
if ( m_vehicleState.m_flLastSpeed > STOPPED_VELOCITY_THRESHOLD_SQR && flSpeedSqr < STOPPED_VELOCITY_THRESHOLD_SQR )
{
SetCondition( COND_VEHICLE_STOPPED );
}
else
{
ClearCondition( COND_VEHICLE_STOPPED );
}
// Store off the speed
m_vehicleState.m_flLastSpeed = flSpeedSqr;
// Find our delta velocity from the last frame
Vector deltaVelocity = ( localVelocity - m_vehicleState.m_vecLastLocalVelocity );
m_vehicleState.m_vecLastLocalVelocity = localVelocity;
// Detect a sudden stop
if ( deltaVelocity.y < passenger_impact_response_threshold.GetFloat() )
{
SetCondition( COND_VEHICLE_HARD_IMPACT );
GetOuter()->GetExpresser()->Speak( TLK_PASSENGER_IMPACT );
}
// Detect being overturned
if ( m_hVehicle->IsOverturned() )
{
if ( m_vehicleState.m_bWasOverturned == false )
{
SetCondition( COND_VEHICLE_OVERTURNED );
m_vehicleState.m_bWasOverturned = true;
if ( m_vehicleState.m_flNextWarningTime < gpGlobals->curtime )
{
// FIXME: Delay for a bit
GetOuter()->GetExpresser()->Speak( TLK_PASSENGER_OVERTURNED );
m_vehicleState.m_flNextWarningTime = gpGlobals->curtime + 5.0f;
}
}
}
else
{
ClearCondition( COND_VEHICLE_OVERTURNED );
m_vehicleState.m_bWasOverturned = false;
}
// See if we're going to collide with anything soon
GatherVehicleCollisionConditions( localVelocity );
}
//-----------------------------------------------------------------------------
// Purpose: Handles exit failure notifications
//-----------------------------------------------------------------------------
void CAI_PassengerBehaviorCompanion::OnExitVehicleFailed( void )
{
m_nExitAttempts++;
}
//-----------------------------------------------------------------------------
// Purpose: Track how long we've been overturned
//-----------------------------------------------------------------------------
void CAI_PassengerBehaviorCompanion::UpdateStuckStatus( void )
{
if ( m_hVehicle == NULL )
return;
// Always clear this to start out with
ClearCondition( COND_CAN_LEAVE_STUCK_VEHICLE );
// If we can't exit the vehicle, then don't bother with these checks
if ( m_hVehicle->NPC_CanExitVehicle( GetOuter(), true ) == false )
return;
bool bVisibleToPlayer = false;
bool bPlayerInVehicle = false;
CBasePlayer *pPlayer = UTIL_PlayerByIndex( 1 );
if ( pPlayer )
{
bVisibleToPlayer = pPlayer->FInViewCone( GetOuter()->GetAbsOrigin() );
bPlayerInVehicle = pPlayer->IsInAVehicle();
}
// If we're not overturned, just reset our counter
if ( m_vehicleState.m_bWasOverturned == false )
{
m_flOverturnedDuration = 0.0f;
m_flUnseenDuration = 0.0f;
}
else
{
// Add up the time since we last checked
m_flOverturnedDuration += ( gpGlobals->curtime - GetLastThink() );
}
// Warn about being stuck upside-down if it's been long enough
if ( m_flOverturnedDuration > MIN_OVERTURNED_WARN_DURATION && m_flNextOverturnWarning < gpGlobals->curtime )
{
SetCondition( COND_WARN_OVERTURNED );
}
// If the player can see us or is still in the vehicle, we never exit
if ( bVisibleToPlayer || bPlayerInVehicle )
{
// Reset our timer
m_flUnseenDuration = 0.0f;
return;
}
// Add up the time since we last checked
m_flUnseenDuration += ( gpGlobals->curtime - GetLastThink() );
// If we've been overturned for long enough or tried to exit one too many times
if ( m_vehicleState.m_bWasOverturned )
{
if ( m_flUnseenDuration > MIN_OVERTURNED_DURATION )
{
SetCondition( COND_CAN_LEAVE_STUCK_VEHICLE );
}
}
else if ( m_nExitAttempts >= MIN_FAILED_EXIT_ATTEMPTS )
{
// The player can't be looking at us
SetCondition( COND_CAN_LEAVE_STUCK_VEHICLE );
}
}
//-----------------------------------------------------------------------------
// Purpose: Gather conditions for our use in making decisions
//-----------------------------------------------------------------------------
void CAI_PassengerBehaviorCompanion::GatherConditions( void )
{
// Code below relies on these conditions being set first!
BaseClass::GatherConditions();
// In-car conditions
if ( GetPassengerState() == PASSENGER_STATE_INSIDE )
{
// Get info on how we're driving
GatherVehicleStateConditions();
// See if we're upside-down
UpdateStuckStatus();
}
// Make sure a vehicle doesn't stray from its mark
if ( IsCurSchedule( SCHED_PASSENGER_RUN_TO_ENTER_VEHICLE ) )
{
if ( m_VehicleMonitor.TargetMoved( m_hVehicle ) )
{
SetCondition( COND_VEHICLE_MOVED_FROM_MARK );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_PassengerBehaviorCompanion::AimGun( void )
{
// Aim at enemies we may have
if ( GetEnemy() && HasCondition( COND_SEE_ENEMY ) )
{
Vector vecShootOrigin = GetOuter()->Weapon_ShootPosition();
Vector vecShootDir = GetOuter()->GetShootEnemyDir( vecShootOrigin, false );
//NDebugOverlay::Cross3D( vecShootOrigin, 32, 255, 0, 0, true, 0.5f );
//NDebugOverlay::Line( vecShootOrigin, vecShootOrigin + ( vecShootDir * 128 ), 255, 0, 0, true, 0.5f );
GetOuter()->SetAim( vecShootDir );
}
else
{
// Stop aiming
GetOuter()->RelaxAim();
}
}
//-----------------------------------------------------------------------------
// Purpose: Select schedules when we're riding in the car
//-----------------------------------------------------------------------------
int CAI_PassengerBehaviorCompanion::SelectScheduleInsideVehicle( void )
{
// Overturned
if ( HasCondition( COND_VEHICLE_OVERTURNED ) )
return SCHED_PASSENGER_OVERTURNED;
if ( HasCondition( COND_VEHICLE_HARD_IMPACT ) )
return SCHED_PASSENGER_IMPACT;
// Look for exiting the vehicle
if ( HasCondition( COND_CAN_LEAVE_STUCK_VEHICLE ) )
return SCHED_PASSENGER_EXIT_STUCK_VEHICLE;
// Fire on targets
if ( GetEnemy() )
{
// Always face
GetOuter()->AddLookTarget( GetEnemy(), 1.0f, 2.0f );
if ( HasCondition( COND_CAN_RANGE_ATTACK1 ) && ( GetOuter()->GetShotRegulator()->IsInRestInterval() == false ) )
return SCHED_PASSENGER_RANGE_ATTACK1;
}
// Say an overturned line
if ( HasCondition( COND_WARN_OVERTURNED ) )
{
GetOuter()->GetExpresser()->Speak( TLK_PASSENGER_REQUEST_UPRIGHT );
m_flNextOverturnWarning = gpGlobals->curtime + random->RandomFloat( 5.0f, 10.0f );
ClearCondition( COND_WARN_OVERTURNED );
}
return SCHED_NONE;
}
//-----------------------------------------------------------------------------
// Purpose: Select schedules while we're outisde the car
//-----------------------------------------------------------------------------
int CAI_PassengerBehaviorCompanion::SelectScheduleOutsideVehicle( void )
{
// Reset our mark
m_VehicleMonitor.SetMark( m_hVehicle, 8.0f );
// Wait if the vehicle is moving
if ( ( GetVehicleSpeed() > STOPPED_VELOCITY_THRESHOLD ) || m_hVehicle->IsOverturned() )
{
GetOuter()->SetTarget( m_hVehicle );
return SCHED_PASSENGER_RUN_TO_ENTER_VEHICLE_FAILED;
}
// If we intend to enter, run to the vehicle
if ( m_PassengerIntent == PASSENGER_INTENT_ENTER )
return SCHED_PASSENGER_RUN_TO_ENTER_VEHICLE;
return SCHED_NONE;
}
//-----------------------------------------------------------------------------
// Purpose: Overrides the schedule selection
// Output : int - Schedule to play
//-----------------------------------------------------------------------------
int CAI_PassengerBehaviorCompanion::SelectSchedule( void )
{
// Entering schedule
if ( HasCondition( COND_ENTERING_VEHICLE ) )
{
ClearCondition( COND_ENTERING_VEHICLE );
return SCHED_PASSENGER_RUN_TO_ENTER_VEHICLE;
}
// Handle schedules based on our passenger state
if ( GetPassengerState() == PASSENGER_STATE_OUTSIDE )
{
int nSched = SelectScheduleOutsideVehicle();
if ( nSched != SCHED_NONE )
return nSched;
}
else if ( GetPassengerState() == PASSENGER_STATE_INSIDE )
{
int nSched = SelectScheduleInsideVehicle();
if ( nSched != SCHED_NONE )
return nSched;
}
return BaseClass::SelectSchedule();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CAI_PassengerBehaviorCompanion::SelectFailSchedule( int failedSchedule, int failedTask, AI_TaskFailureCode_t taskFailCode )
{
switch( failedTask )
{
case TASK_GET_PATH_TO_VEHICLE_ENTRY_POINT:
{
// If we're not close enough, then get nearer the target
if ( UTIL_DistApprox( m_hVehicle->GetAbsOrigin(), GetOuter()->GetAbsOrigin() ) > PASSENGER_NEAR_VEHICLE_THRESHOLD )
return SCHED_PASSENGER_RUN_TO_ENTER_VEHICLE_FAILED;
// Stand around and wait for something to open up
GetOuter()->SetTarget( m_hVehicle );
return SCHED_PASSENGER_ENTER_VEHICLE_PAUSE;
}
break;
case TASK_GET_PATH_TO_NEAR_VEHICLE:
return SCHED_PASSENGER_ENTER_VEHICLE_PAUSE;
break;
}
return BaseClass::SelectFailSchedule( failedSchedule, failedTask, taskFailCode );
}
//-----------------------------------------------------------------------------
// Purpose: Start to enter the vehicle
//-----------------------------------------------------------------------------
void CAI_PassengerBehaviorCompanion::EnterVehicle( void )
{
BaseClass::EnterVehicle();
m_nExitAttempts = 0;
m_VehicleMonitor.SetMark( m_hVehicle, 8.0f );
// Remove this flag because we're sitting so close we always think we're going to hit the player
// FIXME: We need to store this state so we don't incorrectly restore it later
GetOuter()->CapabilitiesRemove( bits_CAP_NO_HIT_PLAYER );
// Discard enemies quickly
GetOuter()->GetEnemies()->SetEnemyDiscardTime( 2.0f );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_PassengerBehaviorCompanion::FinishEnterVehicle( void )
{
BaseClass::FinishEnterVehicle();
// We succeeded
ResetVehicleEntryFailedState();
}
//-----------------------------------------------------------------------------
// Purpose: Vehicle has been completely exited
//-----------------------------------------------------------------------------
void CAI_PassengerBehaviorCompanion::FinishExitVehicle( void )
{
BaseClass::FinishExitVehicle();
m_nExitAttempts = 0;
m_VehicleMonitor.ClearMark();
// FIXME: We need to store this state so we don't incorrectly restore it later
GetOuter()->CapabilitiesAdd( bits_CAP_NO_HIT_PLAYER );
// FIXME: Restore this properly
GetOuter()->GetEnemies()->SetEnemyDiscardTime( AI_DEF_ENEMY_DISCARD_TIME );
}
//-----------------------------------------------------------------------------
// Purpose: Tries to build a route to the entry point of the target vehicle.
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAI_PassengerBehaviorCompanion::FindPathToVehicleEntryPoint( void )
{
// Set our custom move name
bool bFindNearest = ( GetOuter()->m_NPCState == NPC_STATE_COMBAT || GetOuter()->m_NPCState == NPC_STATE_ALERT );
int nSequence = FindEntrySequence( bFindNearest );
if ( nSequence == -1 )
return false;
// We have to do this specially because the activities are not named
SetTransitionSequence( nSequence );
// Get the entry position
Vector vecEntryPoint;
QAngle vecEntryAngles;
GetEntryPoint( m_nTransitionSequence, &vecEntryPoint, &vecEntryAngles );
// Find the actual point on the ground to base our pathfinding on
Vector vecActualPoint;
if ( FindGroundAtPosition( vecEntryPoint, 16, 64, &vecActualPoint ) == false )
{
MarkVehicleEntryFailed( vecEntryPoint );
return false;
}
// If we're already close enough, just succeed
float flDistToGoal = ( GetOuter()->GetAbsOrigin() - vecActualPoint ).Length();
if ( flDistToGoal < 8 )
return true;
// Setup our goal
AI_NavGoal_t goal( GOALTYPE_LOCATION );
goal.arrivalActivity = ACT_SCRIPT_CUSTOM_MOVE;
goal.dest = vecActualPoint;
// Try and set a direct route
if ( GetOuter()->GetNavigator()->SetGoal( goal ) )
{
GetOuter()->GetNavigator()->SetArrivalDirection( vecEntryAngles );
//GetOuter()->GetNavigator()->SetArrivalActivity( ACT_SCRIPT_CUSTOM_MOVE );
//GetOuter()->GetNavigator()->SetArrivalSpeed( 64 );
return true;
}
// We failed, so remember it
MarkVehicleEntryFailed( vecEntryPoint );
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Tests the route and position to see if it's valid
// Input : &vecTestPos - position to test
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAI_PassengerBehaviorCompanion::CanExitAtPosition( const Vector &vecTestPos )
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex( 1 );
if ( pPlayer == NULL )
return false;
// Can't be in our potential view
if ( pPlayer->FInViewCone( vecTestPos ) )
return false;
// Check to see if that path is clear and valid
return IsValidTransitionPoint( GetOuter()->WorldSpaceCenter(), vecTestPos );
}
#define NUM_EXIT_ITERATIONS 8
//-----------------------------------------------------------------------------
// Purpose: Find a position we can use to exit the vehicle via teleportation
// Input : *vecResult - safe place to exit to
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAI_PassengerBehaviorCompanion::GetStuckExitPos( Vector *vecResult )
{
// Get our right direction
Vector vecVehicleRight;
m_hVehicle->GetVectors( NULL, &vecVehicleRight, NULL );
// Get the vehicle's rough horizontal bounds
float flVehicleRadius = m_hVehicle->CollisionProp()->BoundingRadius2D();
// Use the vehicle's center as our hub
Vector vecCenter = m_hVehicle->WorldSpaceCenter();
// Angle whose tan is: y/x
float flCurAngle = atan2f( vecVehicleRight.y, vecVehicleRight.x );
float flAngleIncr = (M_PI*2.0f)/(float)NUM_EXIT_ITERATIONS;
Vector vecTestPos;
// Test a number of discrete exit routes
for ( int i = 0; i <= NUM_EXIT_ITERATIONS-1; i++ )
{
// Get our position
SinCos( flCurAngle, &vecTestPos.y, &vecTestPos.x );
vecTestPos.z = 0.0f;
vecTestPos *= flVehicleRadius;
vecTestPos += vecCenter;
// Test the position
if ( CanExitAtPosition( vecTestPos ) )
{
// Take the result
*vecResult = vecTestPos;
return true;
}
// Move to the next iteration
flCurAngle += flAngleIncr;
}
// None found
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Attempt to get out of an overturned vehicle when the player isn't looking
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAI_PassengerBehaviorCompanion::ExitStuckVehicle( void )
{
// Try and find an exit position
Vector vecExitPos;
if ( GetStuckExitPos( &vecExitPos ) == false )
return false;
// Detach from the parent
GetOuter()->SetParent( NULL );
// Do all necessary clean-up
FinishExitVehicle();
// Teleport to the destination
// TODO: Make sure that the player can't see this!
GetOuter()->Teleport( &vecExitPos, &vec3_angle, &vec3_origin );
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_PassengerBehaviorCompanion::StartTask( const Task_t *pTask )
{
// We need to override these so we never face
if ( GetPassengerState() == PASSENGER_STATE_INSIDE )
{
if ( pTask->iTask == TASK_FACE_TARGET ||
pTask->iTask == TASK_FACE_ENEMY ||
pTask->iTask == TASK_FACE_IDEAL ||
pTask->iTask == TASK_FACE_HINTNODE ||
pTask->iTask == TASK_FACE_LASTPOSITION ||
pTask->iTask == TASK_FACE_PATH ||
pTask->iTask == TASK_FACE_PLAYER ||
pTask->iTask == TASK_FACE_REASONABLE ||
pTask->iTask == TASK_FACE_SAVEPOSITION ||
pTask->iTask == TASK_FACE_SCRIPT )
{
return TaskComplete();
}
}
switch ( pTask->iTask )
{
case TASK_GET_PATH_TO_VEHICLE_ENTRY_POINT:
{
// Reserve an entry point
if ( ReserveEntryPoint( VEHICLE_SEAT_ANY ) == false )
{
TaskFail( "No valid entry point!\n" );
return;
}
// Find where we're going
if ( FindPathToVehicleEntryPoint() )
{
TaskComplete();
return;
}
// We didn't find a path
TaskFail( "TASK_GET_PATH_TO_VEHICLE_ENTRY_POINT: Unable to run to entry point" );
}
break;
case TASK_GET_PATH_TO_TARGET:
{
GetOuter()->SetTarget( m_hVehicle );
BaseClass::StartTask( pTask );
}
break;
case TASK_GET_PATH_TO_NEAR_VEHICLE:
{
// Find the passenger offset we're going for
Vector vecRight;
m_hVehicle->GetVectors( NULL, &vecRight, NULL );
Vector vecTargetOffset = vecRight * 64.0f;
// Try and find a path near there
AI_NavGoal_t goal( GOALTYPE_TARGETENT, vecTargetOffset, AIN_DEF_ACTIVITY, 64.0f, AIN_UPDATE_TARGET_POS, m_hVehicle );
GetOuter()->SetTarget( m_hVehicle );
if ( GetOuter()->GetNavigator()->SetGoal( goal ) )
{
TaskComplete();
return;
}
TaskFail( "Unable to find path to get closer to vehicle!\n" );
return;
}
break;
case TASK_PASSENGER_RELOAD:
{
GetOuter()->SetIdealActivity( ACT_PASSENGER_RELOAD );
return;
}
break;
case TASK_PASSENGER_EXIT_STUCK_VEHICLE:
{
if ( ExitStuckVehicle() )
{
TaskComplete();
return;
}
TaskFail("Unable to exit overturned vehicle!\n");
}
break;
case TASK_PASSENGER_OVERTURNED:
{
// Go into our overturned animation
if ( GetOuter()->GetIdealActivity() != ACT_PASSENGER_OVERTURNED )
{
GetOuter()->SetIdealActivity( ACT_PASSENGER_OVERTURNED );
}
TaskComplete();
}
break;
case TASK_PASSENGER_IMPACT:
{
// Go into our impact animation
GetOuter()->ResetIdealActivity( ACT_PASSENGER_IMPACT );
// Delay for twice the duration of our impact animation
int nSequence = GetOuter()->SelectWeightedSequence( ACT_PASSENGER_IMPACT );
GetOuter()->SetNextAttack( gpGlobals->curtime + (GetOuter()->SequenceDuration( nSequence ) * 2.0f ) );
}
break;
default:
BaseClass::StartTask( pTask );
break;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_PassengerBehaviorCompanion::RunTask( const Task_t *pTask )
{
switch ( pTask->iTask )
{
case TASK_PASSENGER_RELOAD:
{
if ( GetOuter()->IsSequenceFinished() )
{
TaskComplete();
}
}
break;
case TASK_PASSENGER_IMPACT:
{
if ( GetOuter()->IsSequenceFinished() )
{
TaskComplete();
return;
}
}
break;
default:
BaseClass::RunTask( pTask );
break;
}
}
//-----------------------------------------------------------------------------
// Purpose: Add custom interrupt conditions
//-----------------------------------------------------------------------------
void CAI_PassengerBehaviorCompanion::BuildScheduleTestBits( void )
{
// Always break on being able to exit
if ( GetPassengerState() == PASSENGER_STATE_INSIDE )
{
GetOuter()->SetCustomInterruptCondition( GetClassScheduleIdSpace()->ConditionLocalToGlobal( COND_CAN_LEAVE_STUCK_VEHICLE ) );
GetOuter()->SetCustomInterruptCondition( GetClassScheduleIdSpace()->ConditionLocalToGlobal( COND_VEHICLE_HARD_IMPACT) );
if ( GetOuter()->IsCurSchedule( SCHED_PASSENGER_OVERTURNED ) == false )
{
GetOuter()->SetCustomInterruptCondition( GetClassScheduleIdSpace()->ConditionLocalToGlobal( COND_VEHICLE_OVERTURNED ) );
}
}
BaseClass::BuildScheduleTestBits();
}
//-----------------------------------------------------------------------------
// Purpose: Attempt to build a local route to a goal and append it to the chain (if it exists)
// Input : &vecStart - Path's starting position
// &vecEnd - Path's ending position
// **pWaypoints - pointer to a waypoint list to append the data to
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAI_PassengerBehaviorCompanion::AppendLocalPath( const Vector &vecStart, const Vector &vecEnd, AI_Waypoint_t **pWaypoints )
{
// Find the next waypoint to use
AI_Waypoint_t *pNextRoute = GetOuter()->GetPathfinder()->BuildLocalRoute( vecStart, vecEnd, NULL, 0, NO_NODE, bits_BUILD_GROUND, 8.0f );
if ( pNextRoute == NULL )
return false;
// We cannot simply our route
pNextRoute->ModifyFlags( bits_WP_DONT_SIMPLIFY, true );
// Start the list
if ( (*pWaypoints) == NULL )
{
*pWaypoints = pNextRoute;
}
else
{
// Concat the list
AddWaypointLists( (*pWaypoints), pNextRoute );
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Find the "quadrant" in which we're aligned around an entity
// Input : &vecPos - position to test
// *pCenter - Center entity (facing and origin used)
// Output : top-left = 0, bottom-left = 1, bottom-right = 2, top-right = 3 (winding counter-clockwise)
//-----------------------------------------------------------------------------
inline int FindQuadrantForPosition( const Vector &vecPos, CBaseEntity *pCenterEnt )
{
// Find the direction to our goal entity
Vector vecPosToGoalDir = ( pCenterEnt->GetAbsOrigin() - vecPos );
vecPosToGoalDir.z = 0.0f;
VectorNormalize( vecPosToGoalDir );
// Get our goal entity's facing
Vector vecForward, vecRight;
pCenterEnt->GetVectors( &vecForward, &vecRight, NULL );
// Find in what "quadrant" the target is in
float flForwardDot = DotProduct( vecForward, vecPosToGoalDir );
float flRightDot = DotProduct( vecRight, vecPosToGoalDir );
int nQuadrant;
if ( flForwardDot < 0.0f )
{
// Top right / left
nQuadrant = ( flRightDot < 0.0f ) ? 3 : 0;
}
else
{
// Bottom right / left
nQuadrant = ( flRightDot < 0.0f ) ? 2 : 1;
}
return nQuadrant;
}
//-----------------------------------------------------------------------------
// Purpose: Get the next node (with wrapping) around a circularly wound path
// Input : nLastNode - The starting node
// nDirection - Direction we're moving
// nNumNodes - Total nodes in the chain
//-----------------------------------------------------------------------------
inline int GetNextNode( int nLastNode, int nDirection, int nNumNodes )
{
// FIXME: Account for non-singular steps
int nNextNode = nLastNode + nDirection;
if ( nNextNode > (nNumNodes-1) )
nNextNode = 0;
else if ( nNextNode < 0 )
nNextNode = (nNumNodes-1);
return nNextNode;
}
//-----------------------------------------------------------------------------
// Purpose: Attempts to construct a local path given a set of nodes and criteria
// Input : *vecPositions - positions of the nodes to use
// nNumNodes - number of nodes supplied
// nDirection - direction in which to traverse the node list
// Output : Returns the path constructed, NULL if none could be made
//-----------------------------------------------------------------------------
AI_Waypoint_t *CAI_PassengerBehaviorCompanion::BuildNodeRouteAroundVehicle( const VehicleAvoidParams_t &avoidParams )
{
// DEBUG
/*
for ( int i = 0; i < avoidParams.nNumNodes; i++ )
{
if ( i == avoidParams.nStartNode )
{
NDebugOverlay::Box( avoidParams.pNodePositions[i], -Vector(14,14,14), Vector(14,14,14), 0, 255, 0, true, 1.0f );
}
else if ( i == avoidParams.nEndNode )
{
NDebugOverlay::Box( avoidParams.pNodePositions[i], -Vector(14,14,14), Vector(14,14,14), 0, 0, 255, true, 1.0f );
}
else
{
NDebugOverlay::Box( avoidParams.pNodePositions[i], -Vector(14,14,14), Vector(14,14,14), 255, 0, 0, true, 1.0f );
}
}
*/
// END DEBUG
// Get the next node along the path
int nNextNode = GetNextNode( avoidParams.nStartNode, avoidParams.nDirection, avoidParams.nNumNodes );
// NDebugOverlay::Cross3D( avoidParams.pNodePositions[nNextNode], 32.0f, 255, 0, 0, true, 2.0f );
// If we're not moving directly to the goal, see if we're already along the path
if ( nNextNode != avoidParams.nEndNode )
{
// Find the direction between us and our first node
Vector vecStartDir = ( GetOuter()->GetAbsOrigin() - avoidParams.pNodePositions[avoidParams.nStartNode] );
VectorNormalize( vecStartDir );
// Find the direction of the next leg of the path
Vector vecPathDir = ( avoidParams.pNodePositions[avoidParams.nStartNode] - avoidParams.pNodePositions[nNextNode] );
VectorNormalize( vecPathDir );
// We're closer to the next node on our path, just go there!
if ( DotProduct( vecStartDir, vecPathDir ) < 0.0f )
{
// Validate that we have a clear shot to it
trace_t tr;
UTIL_TraceHull( GetOuter()->GetAbsOrigin(), avoidParams.pNodePositions[nNextNode], GetOuter()->GetHullMins(), GetOuter()->GetHullMaxs(), MASK_NPCSOLID, GetOuter(), COLLISION_GROUP_VEHICLE, &tr );
if ( tr.fraction < 1.0f )
{
// Nope, run to our start
nNextNode = avoidParams.nStartNode;
//NDebugOverlay::HorzArrow( GetOuter()->GetAbsOrigin(), avoidParams.pNodePositions[nNextNode], 4, 255, 0, 0, 128, true, 2.0f );
}
/*else
{
NDebugOverlay::HorzArrow( GetOuter()->GetAbsOrigin(), avoidParams.pNodePositions[nNextNode], 4, 0, 255, 0, 128, true, 2.0f );
}*/
}
}
AI_Waypoint_t *pHeadRoute = NULL;
// Attempt to path to our next node (skipping the first if possible)
if ( AppendLocalPath( avoidParams.vecStartPos, avoidParams.pNodePositions[nNextNode], &pHeadRoute ) == false )
{
//NDebugOverlay::HorzArrow( avoidParams.vecStartPos, avoidParams.pNodePositions[nNextNode], 32, 255, 0, 0, 128, true, 2.0f );
// Failing that, just run to our start position
nNextNode = avoidParams.nStartNode;
if ( AppendLocalPath( avoidParams.vecStartPos, avoidParams.pNodePositions[nNextNode], &pHeadRoute ) == false )
{
//NDebugOverlay::HorzArrow( avoidParams.vecStartPos, avoidParams.pNodePositions[nNextNode], 32, 255, 0, 0, 128, true, 2.0f );
return false;
}
}
// Now walk the path and keep adding point on until we're finished
int nLastNode = 0;
int nSteps = 0;
while ( nSteps < avoidParams.nNumNodes )
{
// Move the node ahead
nLastNode = nNextNode;
nNextNode = GetNextNode( nNextNode, avoidParams.nDirection, avoidParams.nNumNodes );
// Try the next leg of the path
if ( AppendLocalPath( avoidParams.pNodePositions[nLastNode], avoidParams.pNodePositions[nNextNode], &pHeadRoute ) == false )
{
//NDebugOverlay::HorzArrow( avoidParams.pNodePositions[nLastNode], avoidParams.pNodePositions[nNextNode], 16, 255, 0, 0, 128, true, 2.0f );
return NULL;
}
// See if we're at the final node (finished if we are)
if ( nNextNode == avoidParams.nEndNode )
return pHeadRoute;
//NDebugOverlay::HorzArrow( avoidParams.pNodePositions[nLastNode], avoidParams.pNodePositions[nNextNode], 16, 0, 255, 0, 128, true, 2.0f );
// Increment the counter
nSteps++;
}
// No path found!
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Quickly walk a circular path to find the winding that's shortest
// Input : *pParams - avoid params
//-----------------------------------------------------------------------------
inline void FindShortestDirectionToNode( VehicleAvoidParams_t *pParams )
{
int nNextNode = GetNextNode( pParams->nStartNode, 1, pParams->nNumNodes );
int nDistance = 1;
// Try going counter-clockwise
for ( int i = 0; i < pParams->nNumNodes; i++ )
{
if ( nNextNode == pParams->nEndNode )
break;
nNextNode = GetNextNode( nNextNode, 1, pParams->nNumNodes );
nDistance++;
}
nNextNode = GetNextNode( pParams->nStartNode, -1, pParams->nNumNodes );
// Now go the other way and see if it's shorter to do so
for ( int i = 0; i < nDistance; i++ )
{
if ( nNextNode == pParams->nEndNode )
{
pParams->nDirection = -1;
return;
}
nNextNode = GetNextNode( nNextNode, -1, pParams->nNumNodes );
}
pParams->nDirection = 1;
}
//-----------------------------------------------------------------------------
// Purpose: Try to build a route around a blocking vehicle (lest we bump into it dumbly)
// Output : Returns true if a path was built successfully
//-----------------------------------------------------------------------------
bool CAI_PassengerBehaviorCompanion::BuildVehicleAvoidancePath( CBaseEntity *pVehicle, const Vector &vecMoveDir )
{
// Get our local OBB and inflate it by our hull size
Vector vecLocalMins = pVehicle->CollisionProp()->OBBMins();
Vector vecLocalMaxs = pVehicle->CollisionProp()->OBBMaxs();
// FIXME: For some reason the OBB is crazy-big!
// FIXME: Shrink the OBB for giggles
vecLocalMins[0] += GetOuter()->GetHullWidth()*0.5f;
vecLocalMins[1] += GetOuter()->GetHullWidth()*0.5f;
vecLocalMaxs[0] -= GetOuter()->GetHullWidth()*0.5f;
vecLocalMaxs[1] -= GetOuter()->GetHullWidth()*0.5f;
vecLocalMins[2] = 0.0f;
vecLocalMaxs[2] = 0.0f;
// Get the four corners in worldspace as our points of circumnavigation
Vector vecNodes[4];
Vector vecScratch;
matrix3x4_t matColToWorld = pVehicle->CollisionProp()->CollisionToWorldTransform();
vecScratch.z = 0.0f;
// Top left
vecScratch.x = vecLocalMins.x;
vecScratch.y = vecLocalMaxs.y;
VectorTransform( vecScratch, matColToWorld, vecNodes[0] );
// Bottom left
vecScratch.x = vecLocalMins.x;
vecScratch.y = vecLocalMins.y;
VectorTransform( vecScratch, matColToWorld, vecNodes[1] );
// Bottom right
vecScratch.x = vecLocalMaxs.x;
vecScratch.y = vecLocalMins.y;
VectorTransform( vecScratch, matColToWorld, vecNodes[2] );
// Top right
vecScratch.x = vecLocalMaxs.x;
vecScratch.y = vecLocalMaxs.y;
VectorTransform( vecScratch, matColToWorld, vecNodes[3] );
VehicleAvoidParams_t avoidParams;
// Get the quadrants we're moving between
avoidParams.nStartNode = FindQuadrantForPosition( GetOuter()->GetAbsOrigin(), pVehicle );
avoidParams.nEndNode = FindQuadrantForPosition( GetOuter()->GetNavigator()->GetPath()->ActualGoalPosition(), pVehicle );
// If we're moving within the same quadrant, we've got no path
if ( avoidParams.nStartNode == avoidParams.nEndNode )
return false;
// Get the direction of traversal for the array ( 1 = counter-clockwise )
avoidParams.pNodePositions = vecNodes;
avoidParams.nNumNodes = ARRAYSIZE( vecNodes );
// Specify the points in space we're coming from and going to
avoidParams.vecStartPos = GetOuter()->GetAbsOrigin();
avoidParams.vecGoalPos = GetOuter()->GetNavigator()->GetPath()->ActualGoalPosition();
// Find our shortest path to the node in question
FindShortestDirectionToNode( &avoidParams );
// Try and build a route around the vehicle
AI_Waypoint_t *pAvoidRoute = BuildNodeRouteAroundVehicle( avoidParams );
if ( pAvoidRoute == NULL )
{
// Try the opposite direction
avoidParams.nDirection = -avoidParams.nDirection;
pAvoidRoute = BuildNodeRouteAroundVehicle( avoidParams );
if ( pAvoidRoute == NULL )
return false;
}
// Splice this into our current node path
GetOuter()->GetNavigator()->GetPath()->PrependWaypoints( pAvoidRoute );
GetOuter()->GetNavigator()->SimplifyPath();
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Removes all failed points
//-----------------------------------------------------------------------------
void CAI_PassengerBehaviorCompanion::ResetVehicleEntryFailedState( void )
{
m_FailedEntryPositions.RemoveAll();
}
//-----------------------------------------------------------------------------
// Purpose: Adds a failed position to the list and marks when it occured
// Input : &vecPosition - Position that failed
//-----------------------------------------------------------------------------
void CAI_PassengerBehaviorCompanion::MarkVehicleEntryFailed( const Vector &vecPosition )
{
FailPosition_t failPos;
failPos.flTime = gpGlobals->curtime;
failPos.vecPosition = vecPosition;
m_FailedEntryPositions.AddToTail( failPos );
}
//-----------------------------------------------------------------------------
// Purpose: See if a vector is near enough to a previously failed position
// Input : &vecPosition - position to test
// Output : Returns true if the point is near enough another to be considered equivalent
//-----------------------------------------------------------------------------
bool CAI_PassengerBehaviorCompanion::PointIsWithinEntryFailureRadius( const Vector &vecPosition )
{
// Test this point against our known failed points and reject it if it's too near
for ( int i = 0; i < m_FailedEntryPositions.Count(); i++ )
{
if ( ( vecPosition - m_FailedEntryPositions[i].vecPosition ).LengthSqr() < (32.0f*32.0f) )
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAI_PassengerBehaviorCompanion::OnCalcBaseMove( AILocalMoveGoal_t *pMoveGoal, float distClear, AIMoveResult_t *pResult )
{
// If we've hit something we need to see what it might be
if ( pMoveGoal->bHasTraced && pMoveGoal->directTrace.pObstruction != NULL )
{
// See if we're a buggy
CPropJeepEpisodic *pBuggy = dynamic_cast<CPropJeepEpisodic *>(pMoveGoal->directTrace.pObstruction);
if ( pBuggy != NULL )
{
IServerVehicle *pServerVehicle = pBuggy->GetServerVehicle();
if ( pServerVehicle != NULL )
{
Vector vecGoalPos = GetNavigator()->GetPath()->ActualGoalPosition();
float flGoalDist = ( GetAbsOrigin() - vecGoalPos ).Length();
if ( flGoalDist > distClear )
{
bool bSucceeded = BuildVehicleAvoidancePath( pServerVehicle->GetVehicleEnt(), pMoveGoal->target );
if ( bSucceeded )
{
ResetVehicleEntryFailedState();
return true;
}
// Mark this point as having failed, so try a new entrance when we re-tried
MarkVehicleEntryFailed( GetNavigator()->GetPath()->ActualGoalPosition() );
return false;
}
}
}
}
return BaseClass::OnCalcBaseMove( pMoveGoal, distClear, pResult );
}
//-----------------------------------------------------------------------------
// Purpose: Find the proper sequence to use (weighted by priority or distance from current position)
// to enter the vehicle.
// Input : bNearest - Use distance as the criteria for a "best" sequence. Otherwise the order of the
// seats is their priority.
// Output : int - sequence index
//-----------------------------------------------------------------------------
int CAI_PassengerBehaviorCompanion::FindEntrySequence( bool bNearest /*= false*/ )
{
// Get a list of all our animations
const PassengerSeatAnims_t *pEntryAnims = m_hVehicle->GetServerVehicle()->NPC_GetPassengerSeatAnims( GetOuter(), PASSENGER_SEAT_ENTRY );
if ( pEntryAnims == NULL )
return -1;
// Get the ultimate position we'll end up at
Vector vecStartPos, vecEndPos;
if ( m_hVehicle->GetServerVehicle()->NPC_GetPassengerSeatPosition( GetOuter(), &vecEndPos, NULL ) == false )
return -1;
const CPassengerSeatTransition *pTransition;
Vector vecSeatDir;
float flNearestDist = 99999999999.9f;
float flSeatDist;
int nNearestSequence = -1;
int nSequence;
// Test each animation (sorted by priority) for the best match
for ( int i = 0; i < pEntryAnims->Count(); i++ )
{
// Find the activity for this animation name
pTransition = &pEntryAnims->Element(i);
nSequence = GetOuter()->LookupSequence( STRING( pTransition->GetAnimationName() ) );
if ( nSequence == -1 )
continue;
// Test this entry for validity
GetEntryPoint( nSequence, &vecStartPos );
// See if this entry position is in our list of known unreachable places
if ( PointIsWithinEntryFailureRadius( vecStartPos ) )
continue;
// Check to see if we can use this
if ( IsValidTransitionPoint( vecStartPos, vecEndPos ) )
{
// If we're just looking for the first, we're done
if ( bNearest == false )
return nSequence;
// Otherwise distance is the deciding factor
vecSeatDir = ( vecStartPos - GetOuter()->GetAbsOrigin() );
flSeatDist = VectorNormalize( vecSeatDir );
// Closer, take it
if ( flSeatDist < flNearestDist )
{
flNearestDist = flSeatDist;
nNearestSequence = nSequence;
}
}
}
return nNearestSequence;
}
AI_BEGIN_CUSTOM_SCHEDULE_PROVIDER( CAI_PassengerBehaviorCompanion )
{
DECLARE_ACTIVITY( ACT_PASSENGER_IDLE_AIM )
DECLARE_ACTIVITY( ACT_PASSENGER_RELOAD )
DECLARE_ACTIVITY( ACT_PASSENGER_OVERTURNED )
DECLARE_ACTIVITY( ACT_PASSENGER_IMPACT )
DECLARE_ACTIVITY( ACT_PASSENGER_IMPACT_WEAPON )
DECLARE_ACTIVITY( ACT_PASSENGER_POINT )
DECLARE_ACTIVITY( ACT_PASSENGER_POINT_BEHIND )
DECLARE_ACTIVITY( ACT_PASSENGER_IDLE_READY )
DECLARE_TASK( TASK_GET_PATH_TO_VEHICLE_ENTRY_POINT )
DECLARE_TASK( TASK_GET_PATH_TO_NEAR_VEHICLE )
DECLARE_TASK( TASK_PASSENGER_RELOAD )
DECLARE_TASK( TASK_PASSENGER_EXIT_STUCK_VEHICLE )
DECLARE_TASK( TASK_PASSENGER_OVERTURNED )
DECLARE_TASK( TASK_PASSENGER_IMPACT )
DECLARE_CONDITION( COND_HARD_IMPACT )
DECLARE_CONDITION( COND_VEHICLE_MOVED_FROM_MARK )
DECLARE_CONDITION( COND_VEHICLE_STOPPED )
DECLARE_CONDITION( COND_CAN_LEAVE_STUCK_VEHICLE )
DECLARE_CONDITION( COND_WARN_OVERTURNED )
DEFINE_SCHEDULE
(
SCHED_PASSENGER_RUN_TO_ENTER_VEHICLE,
" Tasks"
" TASK_STOP_MOVING 0"
" TASK_SET_TOLERANCE_DISTANCE 4"
" TASK_SET_ROUTE_SEARCH_TIME 5"
" TASK_GET_PATH_TO_VEHICLE_ENTRY_POINT 0"
" TASK_RUN_PATH 0"
" TASK_WAIT_FOR_MOVEMENT 0"
" TASK_SET_SCHEDULE SCHEDULE:SCHED_PASSENGER_ENTER_VEHICLE"
""
" Interrupts"
" COND_VEHICLE_MOVED_FROM_MARK"
)
DEFINE_SCHEDULE
(
SCHED_PASSENGER_RUN_TO_ENTER_VEHICLE_FAILED,
" Tasks"
" TASK_STOP_MOVING 0"
" TASK_SET_TOLERANCE_DISTANCE 32"
" TASK_SET_ROUTE_SEARCH_TIME 3"
" TASK_GET_PATH_TO_NEAR_VEHICLE 0"
" TASK_RUN_PATH 0"
" TASK_WAIT_FOR_MOVEMENT 0"
""
" Interrupts"
" COND_VEHICLE_MOVED_FROM_MARK"
" COND_VEHICLE_STOPPED"
)
DEFINE_SCHEDULE
(
SCHED_PASSENGER_ENTER_VEHICLE_PAUSE,
" Tasks"
" TASK_STOP_MOVING 1"
" TASK_FACE_TARGET 0"
" TASK_WAIT 2"
""
" Interrupts"
" COND_VEHICLE_STOPPED"
" COND_LIGHT_DAMAGE"
" COND_NEW_ENEMY"
)
DEFINE_SCHEDULE
(
SCHED_PASSENGER_RANGE_ATTACK1,
" Tasks"
" TASK_ANNOUNCE_ATTACK 1" // 1 = primary attack
" TASK_RANGE_ATTACK1 0"
""
" Interrupts"
" COND_NEW_ENEMY"
" COND_ENEMY_DEAD"
" COND_LIGHT_DAMAGE"
" COND_HEAVY_DAMAGE"
" COND_ENEMY_OCCLUDED"
" COND_NO_PRIMARY_AMMO"
" COND_HEAR_DANGER"
" COND_WEAPON_BLOCKED_BY_FRIEND"
" COND_WEAPON_SIGHT_OCCLUDED"
)
DEFINE_SCHEDULE
(
SCHED_PASSENGER_EXIT_STUCK_VEHICLE,
" Tasks"
" TASK_PASSENGER_EXIT_STUCK_VEHICLE 0"
""
" Interrupts"
)
DEFINE_SCHEDULE
(
SCHED_PASSENGER_RELOAD,
" Tasks"
" TASK_PASSENGER_RELOAD 0"
""
" Interrupts"
)
DEFINE_SCHEDULE
(
SCHED_PASSENGER_OVERTURNED,
" Tasks"
" TASK_PASSENGER_OVERTURNED 0"
""
" Interrupts"
)
DEFINE_SCHEDULE
(
SCHED_PASSENGER_IMPACT,
" Tasks"
" TASK_PASSENGER_IMPACT 0"
""
" Interrupts"
)
AI_END_CUSTOM_SCHEDULE_PROVIDER()
}