//----------------------------------------------------------------------------- // Purpose: // Input : *pTask - //----------------------------------------------------------------------------- void CAI_AssaultBehavior::StartTask( const Task_t *pTask ) { switch( pTask->iTask ) { case TASK_RANGE_ATTACK1: BaseClass::StartTask( pTask ); break; case TASK_ASSAULT_DEFER_SCHEDULE_SELECTION: m_flTimeDeferScheduleSelection = gpGlobals->curtime + pTask->flTaskData; TaskComplete(); break; case TASK_ASSAULT_MOVE_AWAY_PATH: break; case TASK_ANNOUNCE_CLEAR: { // If we're at an assault point that can never be cleared, keep waiting forever (if it's the last point in the assault) if ( m_hAssaultPoint && !m_hAssaultPoint->HasSpawnFlags( SF_ASSAULTPOINT_CLEARONARRIVAL ) && m_hAssaultPoint->m_bNeverTimeout && m_hAssaultPoint->m_NextAssaultPointName == NULL_STRING ) { TaskComplete(); return; } ClearAssaultPoint(); TaskComplete(); } break; case TASK_WAIT_ASSAULT_DELAY: { if( m_hRallyPoint ) { GetOuter()->SetWait( m_hRallyPoint->m_flAssaultDelay ); } else { TaskComplete(); } } break; case TASK_AWAIT_ASSAULT_TIMEOUT: // Maintain vigil for as long as the level designer has asked. Wait // and look for targets. GetOuter()->SetWait( m_hAssaultPoint->m_flAssaultTimeout ); break; case TASK_GET_PATH_TO_RALLY_POINT: { AI_NavGoal_t goal( m_hRallyPoint->GetAbsOrigin() ); goal.pTarget = m_hRallyPoint; if ( GetNavigator()->SetGoal( goal ) == false ) { // Try and get as close as possible otherwise AI_NavGoal_t nearGoal( GOALTYPE_LOCATION_NEAREST_NODE, m_hRallyPoint->GetAbsOrigin(), AIN_DEF_ACTIVITY, 256 ); if ( GetNavigator()->SetGoal( nearGoal, AIN_CLEAR_PREVIOUS_STATE ) ) { //FIXME: HACK! The internal pathfinding is setting this without our consent, so override it! ClearCondition( COND_TASK_FAILED ); GetNavigator()->SetArrivalDirection( m_hRallyPoint->GetAbsAngles() ); TaskComplete(); return; } } GetNavigator()->SetArrivalDirection( m_hRallyPoint->GetAbsAngles() ); } break; case TASK_FACE_RALLY_POINT: { UpdateForceCrouch(); GetMotor()->SetIdealYaw( m_hRallyPoint->GetAbsAngles().y ); GetOuter()->SetTurnActivity(); } break; case TASK_GET_PATH_TO_ASSAULT_POINT: { AI_NavGoal_t goal( m_hAssaultPoint->GetAbsOrigin() ); goal.pTarget = m_hAssaultPoint; if ( GetNavigator()->SetGoal( goal ) == false ) { // Try and get as close as possible otherwise AI_NavGoal_t nearGoal( GOALTYPE_LOCATION_NEAREST_NODE, m_hAssaultPoint->GetAbsOrigin(), AIN_DEF_ACTIVITY, 256 ); if ( GetNavigator()->SetGoal( nearGoal, AIN_CLEAR_PREVIOUS_STATE ) ) { //FIXME: HACK! The internal pathfinding is setting this without our consent, so override it! ClearCondition( COND_TASK_FAILED ); GetNavigator()->SetArrivalDirection( m_hAssaultPoint->GetAbsAngles() ); TaskComplete(); return; } } GetNavigator()->SetArrivalDirection( m_hAssaultPoint->GetAbsAngles() ); } break; case TASK_FACE_ASSAULT_POINT: { UpdateForceCrouch(); if( HasCondition( COND_CAN_RANGE_ATTACK1 ) ) { // If I can already fight when I arrive, don't bother running any facing code. Let // The combat AI do that. Turning here will only make the NPC look dumb in a combat // situation because it will take time to turn before attacking. TaskComplete(); } else { GetMotor()->SetIdealYaw( m_hAssaultPoint->GetAbsAngles().y ); GetOuter()->SetTurnActivity(); } } break; case TASK_HIT_ASSAULT_POINT: OnHitAssaultPoint(); TaskComplete(); break; case TASK_HIT_RALLY_POINT: // Once we're stading on it and facing the correct direction, // we have arrived at rally point. GetOuter()->SpeakSentence( ASSAULT_SENTENCE_HIT_RALLY_POINT ); m_bHitRallyPoint = true; m_hRallyPoint->m_OnArrival.FireOutput( GetOuter(), m_hRallyPoint, 0 ); TaskComplete(); break; case TASK_AWAIT_CUE: if( PollAssaultCue() ) { TaskComplete(); } else { // Don't do anything if we've been told to crouch if ( IsForcingCrouch() ) break; else if( m_hRallyPoint->m_RallySequenceName != NULL_STRING ) { // The cue hasn't been given yet, so set to the rally sequence. int sequence = GetOuter()->LookupSequence( STRING( m_hRallyPoint->m_RallySequenceName ) ); if( sequence != -1 ) { GetOuter()->ResetSequence( sequence ); GetOuter()->SetIdealActivity( ACT_DO_NOT_DISTURB ); } } else { // Only chain this task if I'm not playing a custom animation if( GetOuter()->GetEnemy() ) { ChainStartTask( TASK_FACE_ENEMY, 0 ); } } } break; default: BaseClass::StartTask( pTask ); break; } }
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); } }
//----------------------------------------------------------------------------- // Purpose: // Input : *pTask - //----------------------------------------------------------------------------- void CAI_OperatorBehavior::StartTask( const Task_t *pTask ) { switch( pTask->iTask ) { case TASK_OPERATOR_OPERATE: { // Fire the appropriate output! switch( GetGoalEntity()->GetState() ) { case OPERATOR_STATE_NOT_READY: GetGoalEntity()->m_OnMakeReady.FireOutput(NULL, NULL, 0); break; case OPERATOR_STATE_READY: GetGoalEntity()->m_OnBeginOperating.FireOutput(NULL, NULL, 0); break; default: //!!!HACKHACK Assert(0); break; } } TaskComplete(); break; case TASK_OPERATOR_START_PATH: { ChainStartTask(TASK_WALK_PATH); } break; case TASK_OPERATOR_GET_PATH_TO_POSITION: { CBaseEntity *pGoal = m_hPositionEnt; if( !pGoal ) { TaskFail("ai_goal_operator has no location entity\n"); break; } AI_NavGoal_t goal( pGoal->GetAbsOrigin() ); goal.pTarget = pGoal; if ( GetNavigator()->SetGoal( goal ) == false ) { TaskFail( "Can't build path\n" ); /* // Try and get as close as possible otherwise AI_NavGoal_t nearGoal( GOALTYPE_LOCATION_NEAREST_NODE, m_hTargetObject->GetAbsOrigin(), AIN_DEF_ACTIVITY, 256 ); if ( GetNavigator()->SetGoal( nearGoal, AIN_CLEAR_PREVIOUS_STATE ) ) { //FIXME: HACK! The internal pathfinding is setting this without our consent, so override it! ClearCondition( COND_TASK_FAILED ); GetNavigator()->SetArrivalDirection( m_hTargetObject->GetAbsAngles() ); TaskComplete(); return; } */ } GetNavigator()->SetArrivalDirection( pGoal->GetAbsAngles() ); } break; default: BaseClass::StartTask( pTask ); break; } }