diff options
Diffstat (limited to 'game/server/ai_basenpc_schedule.cpp')
| -rw-r--r-- | game/server/ai_basenpc_schedule.cpp | 4764 |
1 files changed, 4764 insertions, 0 deletions
diff --git a/game/server/ai_basenpc_schedule.cpp b/game/server/ai_basenpc_schedule.cpp new file mode 100644 index 0000000..5b7cb1f --- /dev/null +++ b/game/server/ai_basenpc_schedule.cpp @@ -0,0 +1,4764 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: Functions and data pertaining to the NPCs' AI scheduling system. +// Implements default NPC tasks and schedules. +// +//=============================================================================// + + +#include "cbase.h" +#include "ai_default.h" +#include "animation.h" +#include "scripted.h" +#include "soundent.h" +#include "entitylist.h" +#include "basecombatweapon.h" +#include "bitstring.h" +#include "ai_task.h" +#include "ai_network.h" +#include "ai_schedule.h" +#include "ai_hull.h" +#include "ai_node.h" +#include "ai_motor.h" +#include "ai_hint.h" +#include "ai_memory.h" +#include "ai_navigator.h" +#include "ai_tacticalservices.h" +#include "ai_moveprobe.h" +#include "ai_squadslot.h" +#include "ai_squad.h" +#include "ai_speech.h" +#include "game.h" +#include "IEffects.h" +#include "vstdlib/random.h" +#include "ndebugoverlay.h" +#include "tier0/vcrmode.h" +#include "env_debughistory.h" + +// memdbgon must be the last include file in a .cpp file!!! +#include "tier0/memdbgon.h" + +extern ConVar ai_task_pre_script; +extern ConVar ai_use_efficiency; +extern ConVar ai_use_think_optimizations; +#define ShouldUseEfficiency() ( ai_use_think_optimizations.GetBool() && ai_use_efficiency.GetBool() ) + +ConVar ai_simulate_task_overtime( "ai_simulate_task_overtime", "0" ); + +#define MAX_TASKS_RUN 10 + +struct TaskTimings +{ + const char *pszTask; + CFastTimer selectSchedule; + CFastTimer startTimer; + CFastTimer runTimer; +}; + +TaskTimings g_AITaskTimings[MAX_TASKS_RUN]; +int g_nAITasksRun; + +void CAI_BaseNPC::DumpTaskTimings() +{ + DevMsg(" Tasks timings:\n" ); + for ( int i = 0; i < g_nAITasksRun; ++i ) + { + DevMsg( " %32s -- select %5.2f, start %5.2f, run %5.2f\n", g_AITaskTimings[i].pszTask, + g_AITaskTimings[i].selectSchedule.GetDuration().GetMillisecondsF(), + g_AITaskTimings[i].startTimer.GetDuration().GetMillisecondsF(), + g_AITaskTimings[i].runTimer.GetDuration().GetMillisecondsF() ); + + } +} + + +//========================================================= +// FHaveSchedule - Returns true if NPC's GetCurSchedule() +// is anything other than NULL. +//========================================================= +bool CAI_BaseNPC::FHaveSchedule( void ) +{ + if ( GetCurSchedule() == NULL ) + { + return false; + } + + return true; +} + +//========================================================= +// ClearSchedule - blanks out the caller's schedule pointer +// and index. +//========================================================= +void CAI_BaseNPC::ClearSchedule( const char *szReason ) +{ + if (szReason && m_debugOverlays & OVERLAY_TASK_TEXT_BIT) + { + DevMsg( this, AIMF_IGNORE_SELECTED, " Schedule cleared: %s\n", szReason ); + } + + if ( szReason ) + { + ADD_DEBUG_HISTORY( HISTORY_AI_DECISIONS, UTIL_VarArgs( "%s(%d): Schedule cleared: %s\n", GetDebugName(), entindex(), szReason ) ); + } + + m_ScheduleState.timeCurTaskStarted = m_ScheduleState.timeStarted = 0; + m_ScheduleState.bScheduleWasInterrupted = true; + SetTaskStatus( TASKSTATUS_NEW ); + m_IdealSchedule = SCHED_NONE; + m_pSchedule = NULL; + ResetScheduleCurTaskIndex(); + m_InverseIgnoreConditions.SetAll(); +} + +//========================================================= +// FScheduleDone - Returns true if the caller is on the +// last task in the schedule +//========================================================= +bool CAI_BaseNPC::FScheduleDone ( void ) +{ + Assert( GetCurSchedule() != NULL ); + + if ( GetScheduleCurTaskIndex() == GetCurSchedule()->NumTasks() ) + { + return true; + } + + return false; +} + +//========================================================= + +bool CAI_BaseNPC::SetSchedule( int localScheduleID ) +{ + CAI_Schedule *pNewSchedule = GetScheduleOfType( localScheduleID ); + if ( pNewSchedule ) + { + // ken: I'm don't know of any remaining cases, but if you find one, hunt it down as to why the schedule is getting slammed while they're in the middle of script + if (m_hCine != NULL) + { + if (!(localScheduleID == SCHED_SLEEP || localScheduleID == SCHED_WAIT_FOR_SCRIPT || localScheduleID == SCHED_SCRIPTED_WALK || localScheduleID == SCHED_SCRIPTED_RUN || localScheduleID == SCHED_SCRIPTED_CUSTOM_MOVE || localScheduleID == SCHED_SCRIPTED_WAIT || localScheduleID == SCHED_SCRIPTED_FACE) ) + { + Assert( 0 ); + // ExitScriptedSequence(); + } + } + + + m_IdealSchedule = GetGlobalScheduleId( localScheduleID ); + SetSchedule( pNewSchedule ); + return true; + } + return false; +} + +//========================================================= +// SetSchedule - replaces the NPC's schedule pointer +// with the passed pointer, and sets the ScheduleIndex back +// to 0 +//========================================================= +#define SCHEDULE_HISTORY_SIZE 10 +void CAI_BaseNPC::SetSchedule( CAI_Schedule *pNewSchedule ) +{ + Assert( pNewSchedule != NULL ); + + m_ScheduleState.timeCurTaskStarted = m_ScheduleState.timeStarted = gpGlobals->curtime; + m_ScheduleState.bScheduleWasInterrupted = false; + + m_pSchedule = pNewSchedule ; + ResetScheduleCurTaskIndex(); + SetTaskStatus( TASKSTATUS_NEW ); + m_failSchedule = SCHED_NONE; + bool bCondInPVS = HasCondition( COND_IN_PVS ); + m_Conditions.ClearAll(); + if ( bCondInPVS ) + SetCondition( COND_IN_PVS ); + m_bConditionsGathered = false; + GetNavigator()->ClearGoal(); + m_InverseIgnoreConditions.SetAll(); + Forget( bits_MEMORY_TURNING ); + +/* +#if _DEBUG + if ( !ScheduleFromName( pNewSchedule->GetName() ) ) + { + DevMsg( "Schedule %s not in table!!!\n", pNewSchedule->GetName() ); + } +#endif +*/ +// this is very useful code if you can isolate a test case in a level with a single NPC. It will notify +// you of every schedule selection the NPC makes. + + if (m_debugOverlays & OVERLAY_TASK_TEXT_BIT) + { + DevMsg(this, AIMF_IGNORE_SELECTED, "Schedule: %s (time: %.2f)\n", pNewSchedule->GetName(), gpGlobals->curtime ); + } + + ADD_DEBUG_HISTORY( HISTORY_AI_DECISIONS, UTIL_VarArgs("%s(%d): Schedule: %s (time: %.2f)\n", GetDebugName(), entindex(), pNewSchedule->GetName(), gpGlobals->curtime ) ); + +#ifdef AI_MONITOR_FOR_OSCILLATION + if( m_bSelected ) + { + AIScheduleChoice_t choice; + choice.m_flTimeSelected = gpGlobals->curtime; + choice.m_pScheduleSelected = pNewSchedule; + m_ScheduleHistory.AddToHead(choice); + + if( m_ScheduleHistory.Count() > SCHEDULE_HISTORY_SIZE ) + { + m_ScheduleHistory.Remove( SCHEDULE_HISTORY_SIZE ); + } + + assert( m_ScheduleHistory.Count() <= SCHEDULE_HISTORY_SIZE ); + + // No analysis until the vector is full! + if( m_ScheduleHistory.Count() == SCHEDULE_HISTORY_SIZE ) + { + int iNumSelections = m_ScheduleHistory.Count(); + float flTimeSpan = m_ScheduleHistory.Head().m_flTimeSelected - m_ScheduleHistory.Tail().m_flTimeSelected; + float flSelectionsPerSecond = ((float)iNumSelections) / flTimeSpan; + + Msg( "%d selections in %f seconds (avg. %f selections per second)\n", iNumSelections, flTimeSpan, flSelectionsPerSecond ); + + if( flSelectionsPerSecond >= 8.0f ) + { + DevMsg("\n\n %s is thrashing schedule selection:\n", GetDebugName() ); + + for( int i = 0 ; i < m_ScheduleHistory.Count() ; i++ ) + { + AIScheduleChoice_t choice = m_ScheduleHistory[i]; + Msg("--%s %f\n", choice.m_pScheduleSelected->GetName(), choice.m_flTimeSelected ); + } + + Msg("\n"); + + CAI_BaseNPC::m_nDebugBits |= bits_debugDisableAI; + } + } + } +#endif//AI_MONITOR_FOR_OSCILLATION +} + +//========================================================= +// NextScheduledTask - increments the ScheduleIndex +//========================================================= +void CAI_BaseNPC::NextScheduledTask ( void ) +{ + Assert( GetCurSchedule() != NULL ); + + SetTaskStatus( TASKSTATUS_NEW ); + IncScheduleCurTaskIndex(); + + if ( FScheduleDone() ) + { + // Reset memory of failed schedule + m_failedSchedule = NULL; + m_interuptSchedule = NULL; + + // just completed last task in schedule, so make it invalid by clearing it. + SetCondition( COND_SCHEDULE_DONE ); + } +} + + +//----------------------------------------------------------------------------- +// Purpose: This function allows NPCs to modify the interrupt mask for the +// current schedule. This enables them to use base schedules but with +// different interrupt conditions. Implement this function in your +// derived class, and Set or Clear condition bits as you please. +// +// NOTE: Always call the base class in your implementation, but be +// aware of the difference between changing the bits before vs. +// changing the bits after calling the base implementation. +// +// Input : pBitString - Receives the updated interrupt mask. +//----------------------------------------------------------------------------- +void CAI_BaseNPC::BuildScheduleTestBits( void ) +{ + //NOTENOTE: Always defined in the leaf classes +} + + +//========================================================= +// IsScheduleValid - returns true as long as the current +// schedule is still the proper schedule to be executing, +// taking into account all conditions +//========================================================= +bool CAI_BaseNPC::IsScheduleValid() +{ + if ( GetCurSchedule() == NULL || GetCurSchedule()->NumTasks() == 0 ) + { + return false; + } + + //Start out with the base schedule's set interrupt conditions + GetCurSchedule()->GetInterruptMask( &m_CustomInterruptConditions ); + + // Let the leaf class modify our interrupt test bits, but: + // - Don't allow any modifications when scripted + // - Don't modify interrupts for Schedules that set the COND_NO_CUSTOM_INTERRUPTS bit. + if ( m_NPCState != NPC_STATE_SCRIPT && !IsInLockedScene() && !m_CustomInterruptConditions.IsBitSet( COND_NO_CUSTOM_INTERRUPTS ) ) + { + BuildScheduleTestBits(); + } + + //Any conditions set here will always be forced on the interrupt conditions + SetCustomInterruptCondition( COND_NPC_FREEZE ); + + // This is like: m_CustomInterruptConditions &= m_Conditions; + CAI_ScheduleBits testBits; + m_CustomInterruptConditions.And( m_Conditions, &testBits ); + + if (!testBits.IsAllClear()) + { + // If in developer mode save the interrupt text for debug output + if (g_pDeveloper->GetInt()) + { + // Reset memory of failed schedule + m_failedSchedule = NULL; + m_interuptSchedule = GetCurSchedule(); + + // Find the first non-zero bit + for (int i=0;i<MAX_CONDITIONS;i++) + { + if (testBits.IsBitSet(i)) + { + m_interruptText = ConditionName( AI_RemapToGlobal( i ) ); + if (!m_interruptText) + { + m_interruptText = "(UNKNOWN CONDITION)"; + /* + static const char *pError = "ERROR: Unknown condition!"; + DevMsg("%s (%s)\n", pError, GetDebugName()); + m_interruptText = pError; + */ + } + + if (m_debugOverlays & OVERLAY_TASK_TEXT_BIT) + { + DevMsg( this, AIMF_IGNORE_SELECTED, " Break condition -> %s\n", m_interruptText ); + } + + ADD_DEBUG_HISTORY( HISTORY_AI_DECISIONS, UTIL_VarArgs("%s(%d): Break condition -> %s\n", GetDebugName(), entindex(), m_interruptText ) ); + + break; + } + } + + if ( HasCondition( COND_NEW_ENEMY ) ) + { + if (m_debugOverlays & OVERLAY_TASK_TEXT_BIT) + { + DevMsg( this, AIMF_IGNORE_SELECTED, " New enemy: %s\n", GetEnemy() ? GetEnemy()->GetDebugName() : "<NULL>" ); + } + + ADD_DEBUG_HISTORY( HISTORY_AI_DECISIONS, UTIL_VarArgs("%s(%d): New enemy: %s\n", GetDebugName(), entindex(), GetEnemy() ? GetEnemy()->GetDebugName() : "<NULL>" ) ); + } + } + + return false; + } + + if ( HasCondition(COND_SCHEDULE_DONE) || + HasCondition(COND_TASK_FAILED) ) + { +#ifdef DEBUG + if ( HasCondition ( COND_TASK_FAILED ) && m_failSchedule == SCHED_NONE ) + { + // fail! Send a visual indicator. + DevWarning( 2, "Schedule: %s Failed\n", GetCurSchedule()->GetName() ); + + Vector tmp; + CollisionProp()->NormalizedToWorldSpace( Vector( 0.5f, 0.5f, 1.0f ), &tmp ); + tmp.z += 16; + + g_pEffects->Sparks( tmp ); + } +#endif // DEBUG + + // some condition has interrupted the schedule, or the schedule is done + return false; + } + + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: Determines whether or not SelectIdealState() should be called before +// a NPC selects a new schedule. +// +// NOTE: This logic was a source of pure, distilled trouble in Half-Life. +// If you change this function, please supply good comments. +// +// Output : Returns true if yes, false if no +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::ShouldSelectIdealState( void ) +{ +/* + + HERE's the old Half-Life code that used to control this. + + if ( m_IdealNPCState != NPC_STATE_DEAD && + (m_IdealNPCState != NPC_STATE_SCRIPT || m_IdealNPCState == m_NPCState) ) + { + if ( (m_afConditions && !HasConditions(bits_COND_SCHEDULE_DONE)) || + (GetCurSchedule() && (GetCurSchedule()->iInterruptMask & bits_COND_SCHEDULE_DONE)) || + ((m_NPCState == NPC_STATE_COMBAT) && (GetEnemy() == NULL)) ) + { + GetIdealState(); + } + } +*/ + + // Don't get ideal state if you are supposed to be dead. + if ( m_IdealNPCState == NPC_STATE_DEAD ) + return false; + + // If I'm supposed to be in scripted state, but i'm not yet, do not allow + // SelectIdealState() to be called, because it doesn't know how to determine + // that a NPC should be in SCRIPT state and will stomp it with some other + // state. (Most likely ALERT) + if ( (m_IdealNPCState == NPC_STATE_SCRIPT) && (m_NPCState != NPC_STATE_SCRIPT) ) + return false; + + // If the NPC has any current conditions, and one of those conditions indicates + // that the previous schedule completed successfully, then don't run SelectIdealState(). + // Paths between states only exist for interrupted schedules, or when a schedule + // contains a task that suggests that the NPC change state. + if ( !HasCondition(COND_SCHEDULE_DONE) ) + return true; + + // This seems like some sort of hack... + // Currently no schedule that I can see in the AI uses this feature, but if a schedule + // interrupt mask contains bits_COND_SCHEDULE_DONE, then force a call to SelectIdealState(). + // If we want to keep this feature, I suggest we create a new condition with a name that + // indicates exactly what it does. + if ( GetCurSchedule() && GetCurSchedule()->HasInterrupt(COND_SCHEDULE_DONE) ) + return true; + + // Don't call SelectIdealState if a NPC in combat state has a valid enemy handle. Otherwise, + // we need to change state immediately because something unexpected happened to the enemy + // entity (it was blown apart by someone else, for example), and we need the NPC to change + // state. THE REST OF OUR CODE should be robust enough that this can go away!! + if ( (m_NPCState == NPC_STATE_COMBAT) && (GetEnemy() == NULL) ) + return true; + + if ( (m_NPCState == NPC_STATE_IDLE || m_NPCState == NPC_STATE_ALERT) && (GetEnemy() != NULL) ) + return true; + + return false; +} + + +//----------------------------------------------------------------------------- +// Purpose: Returns a new schedule based on current condition bits. +//----------------------------------------------------------------------------- +CAI_Schedule *CAI_BaseNPC::GetNewSchedule( void ) +{ + int scheduleType; + + // + // Schedule selection code here overrides all leaf schedule selection. + // + if (HasCondition(COND_NPC_FREEZE)) + { + scheduleType = SCHED_NPC_FREEZE; + } + else + { + // I dunno how this trend got started, but we need to find the problem. + // You may not be in combat state with no enemy!!! (sjb) 11/4/03 + if( m_NPCState == NPC_STATE_COMBAT && !GetEnemy() ) + { + DevMsg("**ERROR: Combat State with no enemy! slamming to ALERT\n"); + SetState( NPC_STATE_ALERT ); + } + + AI_PROFILE_SCOPE_BEGIN( CAI_BaseNPC_SelectSchedule); + + if ( m_NPCState == NPC_STATE_SCRIPT || m_NPCState == NPC_STATE_DEAD || m_iInteractionState == NPCINT_MOVING_TO_MARK ) + { + scheduleType = CAI_BaseNPC::SelectSchedule(); + } + else + { + scheduleType = SelectSchedule(); + } + + m_IdealSchedule = GetGlobalScheduleId( scheduleType ); + + AI_PROFILE_SCOPE_END(); + } + + return GetScheduleOfType( scheduleType ); +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +CAI_Schedule *CAI_BaseNPC::GetFailSchedule( void ) +{ + int prevSchedule; + int failedTask; + + if ( GetCurSchedule() ) + prevSchedule = GetLocalScheduleId( GetCurSchedule()->GetId() ); + else + prevSchedule = SCHED_NONE; + + const Task_t *pTask = GetTask(); + if ( pTask ) + failedTask = pTask->iTask; + else + failedTask = TASK_INVALID; + + Assert( AI_IdIsLocal( prevSchedule ) ); + Assert( AI_IdIsLocal( failedTask ) ); + + int scheduleType = SelectFailSchedule( prevSchedule, failedTask, m_ScheduleState.taskFailureCode ); + return GetScheduleOfType( scheduleType ); +} + + +//========================================================= +// MaintainSchedule - does all the per-think schedule maintenance. +// ensures that the NPC leaves this function with a valid +// schedule! +//========================================================= + +static bool ShouldStopProcessingTasks( CAI_BaseNPC *pNPC, int taskTime, int timeLimit ) +{ +#ifdef DEBUG + if( ai_simulate_task_overtime.GetBool() ) + return true; +#endif + + // Always stop processing if we've queued up a navigation query on the last task + if ( pNPC->IsNavigationDeferred() ) + return true; + + if ( AIStrongOpt() ) + { + bool bInScript = ( pNPC->GetState() == NPC_STATE_SCRIPT || pNPC->IsCurSchedule( SCHED_SCENE_GENERIC, false ) ); + + // We ran a costly task, don't do it again! + if ( pNPC->HasMemory( bits_MEMORY_TASK_EXPENSIVE ) && bInScript == false ) + return true; + } + + if ( taskTime > timeLimit ) + { + if ( ShouldUseEfficiency() || + pNPC->IsMoving() || + ( pNPC->GetIdealActivity() != ACT_RUN && pNPC->GetIdealActivity() != ACT_WALK ) ) + { + return true; + } + } + return false; +} + +//------------------------------------- + +void CAI_BaseNPC::MaintainSchedule ( void ) +{ + AI_PROFILE_SCOPE(CAI_BaseNPC_RunAI_MaintainSchedule); + extern CFastTimer g_AIMaintainScheduleTimer; + CTimeScope timeScope(&g_AIMaintainScheduleTimer); + + //--------------------------------- + + CAI_Schedule *pNewSchedule; + int i; + bool runTask = true; + +#if defined( VPROF_ENABLED ) +#if defined(DISABLE_DEBUG_HISTORY) + bool bDebugTaskNames = ( developer.GetBool() || ( VProfAI() && g_VProfCurrentProfile.IsEnabled() ) ); +#else + bool bDebugTaskNames = true; +#endif +#else + bool bDebugTaskNames = false; +#endif + + memset( g_AITaskTimings, 0, sizeof(g_AITaskTimings) ); + + g_nAITasksRun = 0; + + const int timeLimit = ( IsDebug() ) ? 16 : 8; + int taskTime = Plat_MSTime(); + + // Reset this at the beginning of the frame + Forget( bits_MEMORY_TASK_EXPENSIVE ); + + // UNDONE: Tune/fix this MAX_TASKS_RUN... This is just here so infinite loops are impossible + bool bStopProcessing = false; + for ( i = 0; i < MAX_TASKS_RUN && !bStopProcessing; i++ ) + { + if ( GetCurSchedule() != NULL && TaskIsComplete() ) + { + // Schedule is valid, so advance to the next task if the current is complete. + NextScheduledTask(); + + // If we finished the current schedule, clear our ignored conditions so they + // aren't applied to the next schedule selection. + if ( HasCondition( COND_SCHEDULE_DONE ) ) + { + // Put our conditions back the way they were after GatherConditions, + // but add in COND_SCHEDULE_DONE. + m_Conditions = m_ConditionsPreIgnore; + SetCondition( COND_SCHEDULE_DONE ); + + m_InverseIgnoreConditions.SetAll(); + } + + // -------------------------------------------------------- + // If debug stepping advance when I complete a task + // -------------------------------------------------------- + if (CAI_BaseNPC::m_nDebugBits & bits_debugStepAI) + { + m_nDebugCurIndex++; + return; + } + } + + int curTiming = g_nAITasksRun; + g_nAITasksRun++; + + // validate existing schedule + if ( !IsScheduleValid() || m_NPCState != m_IdealNPCState ) + { + // Notify the NPC that his schedule is changing + m_ScheduleState.bScheduleWasInterrupted = true; + OnScheduleChange(); + + if ( !HasCondition(COND_NPC_FREEZE) && ( !m_bConditionsGathered || m_bSkippedChooseEnemy ) ) + { + // occurs if a schedule is exhausted within one think + GatherConditions(); + } + + if ( ShouldSelectIdealState() ) + { + NPC_STATE eIdealState = SelectIdealState(); + SetIdealState( eIdealState ); + } + + if ( HasCondition( COND_TASK_FAILED ) && m_NPCState == m_IdealNPCState ) + { + // Get a fail schedule if the previous schedule failed during execution and + // the NPC is still in its ideal state. Otherwise, the NPC would immediately + // select the same schedule again and fail again. + if (m_debugOverlays & OVERLAY_TASK_TEXT_BIT) + { + DevMsg( this, AIMF_IGNORE_SELECTED, " (failed)\n" ); + } + + ADD_DEBUG_HISTORY( HISTORY_AI_DECISIONS, UTIL_VarArgs("%s(%d): (failed)\n", GetDebugName(), entindex() ) ); + + pNewSchedule = GetFailSchedule(); + m_IdealSchedule = pNewSchedule->GetId(); + DevWarning( 2, "(%s) Schedule (%s) Failed at %d!\n", STRING( GetEntityName() ), GetCurSchedule() ? GetCurSchedule()->GetName() : "GetCurSchedule() == NULL", GetScheduleCurTaskIndex() ); + SetSchedule( pNewSchedule ); + } + else + { + // If the NPC is supposed to change state, it doesn't matter if the previous + // schedule failed or completed. Changing state means selecting an entirely new schedule. + SetState( m_IdealNPCState ); + + g_AITaskTimings[curTiming].selectSchedule.Start(); + + pNewSchedule = GetNewSchedule(); + + g_AITaskTimings[curTiming].selectSchedule.End(); + + SetSchedule( pNewSchedule ); + } + } + + if (!GetCurSchedule()) + { + g_AITaskTimings[curTiming].selectSchedule.Start(); + + pNewSchedule = GetNewSchedule(); + + g_AITaskTimings[curTiming].selectSchedule.End(); + + if (pNewSchedule) + { + SetSchedule( pNewSchedule ); + } + } + + if ( !GetCurSchedule() || GetCurSchedule()->NumTasks() == 0 ) + { + DevMsg("ERROR: Missing or invalid schedule!\n"); + SetActivity ( ACT_IDLE ); + return; + } + + AI_PROFILE_SCOPE_BEGIN_( CAI_BaseNPC::GetSchedulingSymbols()->ScheduleIdToSymbol( GetCurSchedule()->GetId() ) ); + + if ( GetTaskStatus() == TASKSTATUS_NEW ) + { + if ( GetScheduleCurTaskIndex() == 0 ) + { + int globalId = GetCurSchedule()->GetId(); + int localId = GetLocalScheduleId( globalId ); // if localId == -1, then it came from a behavior + OnStartSchedule( (localId != -1)? localId : globalId ); + } + + g_AITaskTimings[curTiming].startTimer.Start(); + const Task_t *pTask = GetTask(); + const char *pszTaskName = ( bDebugTaskNames ) ? TaskName( pTask->iTask ) : "ai_task"; + Assert( pTask != NULL ); + g_AITaskTimings[i].pszTask = pszTaskName; + + if (m_debugOverlays & OVERLAY_TASK_TEXT_BIT) + { + DevMsg(this, AIMF_IGNORE_SELECTED, " Task: %s\n", pszTaskName ); + } + + ADD_DEBUG_HISTORY( HISTORY_AI_DECISIONS, UTIL_VarArgs("%s(%d): Task: %s\n", GetDebugName(), entindex(), pszTaskName ) ); + + OnStartTask(); + + m_ScheduleState.taskFailureCode = NO_TASK_FAILURE; + m_ScheduleState.timeCurTaskStarted = gpGlobals->curtime; + + AI_PROFILE_SCOPE_BEGIN_( pszTaskName ); + AI_PROFILE_SCOPE_BEGIN(CAI_BaseNPC_StartTask); + + StartTask( pTask ); + + AI_PROFILE_SCOPE_END(); + AI_PROFILE_SCOPE_END(); + + if ( TaskIsRunning() && !HasCondition(COND_TASK_FAILED) ) + StartTaskOverlay(); + + g_AITaskTimings[curTiming].startTimer.End(); + // DevMsg( "%.2f StartTask( %s )\n", gpGlobals->curtime, m_pTaskSR->GetStringText( pTask->iTask ) ); + } + + AI_PROFILE_SCOPE_END(); + + // UNDONE: Twice?!!! + MaintainActivity(); + + AI_PROFILE_SCOPE_BEGIN_( CAI_BaseNPC::GetSchedulingSymbols()->ScheduleIdToSymbol( GetCurSchedule()->GetId() ) ); + + if ( !TaskIsComplete() && GetTaskStatus() != TASKSTATUS_NEW ) + { + if ( TaskIsRunning() && !HasCondition(COND_TASK_FAILED) && runTask ) + { + const Task_t *pTask = GetTask(); + const char *pszTaskName = ( bDebugTaskNames ) ? TaskName( pTask->iTask ) : "ai_task"; + Assert( pTask != NULL ); + g_AITaskTimings[i].pszTask = pszTaskName; + // DevMsg( "%.2f RunTask( %s )\n", gpGlobals->curtime, m_pTaskSR->GetStringText( pTask->iTask ) ); + g_AITaskTimings[curTiming].runTimer.Start(); + + AI_PROFILE_SCOPE_BEGIN_( pszTaskName ); + AI_PROFILE_SCOPE_BEGIN(CAI_BaseNPC_RunTask); + + int j; + for (j = 0; j < 8; j++) + { + RunTask( pTask ); + + if ( GetTaskInterrupt() == 0 || TaskIsComplete() || HasCondition(COND_TASK_FAILED) ) + break; + + if ( ShouldUseEfficiency() && ShouldStopProcessingTasks( this, Plat_MSTime() - taskTime, timeLimit ) ) + { + bStopProcessing = true; + break; + } + } + AssertMsg( j < 8, "Runaway task interrupt\n" ); + + AI_PROFILE_SCOPE_END(); + AI_PROFILE_SCOPE_END(); + + if ( TaskIsRunning() && !HasCondition(COND_TASK_FAILED) ) + { + if ( IsCurTaskContinuousMove() ) + Remember( bits_MEMORY_MOVED_FROM_SPAWN ); + RunTaskOverlay(); + } + + g_AITaskTimings[curTiming].runTimer.End(); + + // don't do this again this frame + // FIXME: RunTask() should eat some of the clock, depending on what it has done + // runTask = false; + + if ( !TaskIsComplete() ) + { + bStopProcessing = true; + } + } + else + { + bStopProcessing = true; + } + } + + AI_PROFILE_SCOPE_END(); + + // Decide if we should continue on this frame + if ( !bStopProcessing && ShouldStopProcessingTasks( this, Plat_MSTime() - taskTime, timeLimit ) ) + bStopProcessing = true; + } + + // UNDONE: We have to do this so that we have an animation set to blend to if RunTask changes the animation + // RunTask() will always change animations at the end of a script! + // Don't do this twice + MaintainActivity(); + + // -------------------------------------------------------- + // If I'm stopping to debug step, don't animate unless + // I'm in motion + // -------------------------------------------------------- + if (CAI_BaseNPC::m_nDebugBits & bits_debugStepAI) + { + if (!GetNavigator()->IsGoalActive() && + m_nDebugCurIndex >= CAI_BaseNPC::m_nDebugPauseIndex) + { + m_flPlaybackRate = 0; + } + } +} + + +//========================================================= + +bool CAI_BaseNPC::FindCoverPos( CBaseEntity *pEntity, Vector *pResult ) +{ + AI_PROFILE_SCOPE(CAI_BaseNPC_FindCoverPos); + + if ( !GetTacticalServices()->FindLateralCover( pEntity->EyePosition(), 0, pResult ) ) + { + if ( !GetTacticalServices()->FindCoverPos( pEntity->GetAbsOrigin(), pEntity->EyePosition(), 0, CoverRadius(), pResult ) ) + { + return false; + } + } + return true; +} + +//========================================================= + +bool CAI_BaseNPC::FindCoverPosInRadius( CBaseEntity *pEntity, const Vector &goalPos, float coverRadius, Vector *pResult ) +{ + AI_PROFILE_SCOPE(CAI_BaseNPC_FindCoverPosInRadius); + + if ( pEntity == NULL ) + { + // Find cover from self if no enemy available + pEntity = this; + } + + Vector coverPos = vec3_invalid; + CAI_TacticalServices * pTacticalServices = GetTacticalServices(); + const Vector & enemyPos = pEntity->GetAbsOrigin(); + Vector enemyEyePos = pEntity->EyePosition(); + + if( ( !GetSquad() || GetSquad()->GetFirstMember() == this ) && + IsCoverPosition( enemyEyePos, goalPos + GetViewOffset() ) && + IsValidCover( goalPos, NULL ) ) + { + coverPos = goalPos; + } + else if ( !pTacticalServices->FindCoverPos( goalPos, enemyPos, enemyEyePos, 0, coverRadius * 0.5, &coverPos ) ) + { + if ( !pTacticalServices->FindLateralCover( goalPos, enemyEyePos, 0, coverRadius * 0.5, 3, &coverPos ) ) + { + if ( !pTacticalServices->FindCoverPos( goalPos, enemyPos, enemyEyePos, coverRadius * 0.5 - 0.1, coverRadius, &coverPos ) ) + { + pTacticalServices->FindLateralCover( goalPos, enemyEyePos, 0, coverRadius, 5, &coverPos ); + } + } + } + + if ( coverPos == vec3_invalid ) + return false; + *pResult = coverPos; + return true; +} + +//========================================================= + +bool CAI_BaseNPC::FindCoverPos( CSound *pSound, Vector *pResult ) +{ + if ( !GetTacticalServices()->FindCoverPos( pSound->GetSoundReactOrigin(), + pSound->GetSoundReactOrigin(), + MIN( pSound->Volume(), 120.0 ), + CoverRadius(), + pResult ) ) + { + return GetTacticalServices()->FindLateralCover( pSound->GetSoundReactOrigin(), MIN( pSound->Volume(), 60.0 ), pResult ); + } + + return true; +} + +//========================================================= +// Start task - selects the correct activity and performs +// any necessary calculations to start the next task on the +// schedule. +//========================================================= + +//----------------------------------------------------------------------------- +// TASK_TURN_RIGHT / TASK_TURN_LEFT +//----------------------------------------------------------------------------- +void CAI_BaseNPC::StartTurn( float flDeltaYaw ) +{ + float flCurrentYaw; + + flCurrentYaw = UTIL_AngleMod( GetLocalAngles().y ); + GetMotor()->SetIdealYaw( UTIL_AngleMod( flCurrentYaw + flDeltaYaw ) ); + SetTurnActivity(); +} + + +//----------------------------------------------------------------------------- +// TASK_CLEAR_HINTNODE +//----------------------------------------------------------------------------- +void CAI_BaseNPC::ClearHintNode( float reuseDelay ) +{ + if ( m_pHintNode ) + { + if ( m_pHintNode->IsLockedBy(this) ) + m_pHintNode->Unlock(reuseDelay); + m_pHintNode = NULL; + } +} + + +void CAI_BaseNPC::SetHintNode( CAI_Hint *pHintNode ) +{ + m_pHintNode = pHintNode; +} + + +//----------------------------------------------------------------------------- + +bool CAI_BaseNPC::FindCoverFromEnemy( bool bNodesOnly, float flMinDistance, float flMaxDistance ) +{ + CBaseEntity *pEntity = GetEnemy(); + + // Find cover from self if no enemy available + if ( pEntity == NULL ) + pEntity = this; + + Vector coverPos = vec3_invalid; + + ClearHintNode(); + + if ( bNodesOnly ) + { + if ( flMaxDistance == FLT_MAX ) + flMaxDistance = CoverRadius(); + + if ( !GetTacticalServices()->FindCoverPos( pEntity->GetAbsOrigin(), pEntity->EyePosition(), flMinDistance, flMaxDistance, &coverPos ) ) + return false; + } + else + { + if ( !FindCoverPos( pEntity, &coverPos ) ) + return false; + } + + AI_NavGoal_t goal( GOALTYPE_COVER, coverPos, ACT_RUN, AIN_HULL_TOLERANCE ); + + if ( !GetNavigator()->SetGoal( goal ) ) + return false; + + // FIXME: add to goal + if (GetHintNode()) + { + GetNavigator()->SetArrivalActivity( GetCoverActivity( GetHintNode() ) ); + GetNavigator()->SetArrivalDirection( GetHintNode()->GetDirection() ); + } + + return true; +} + + +//----------------------------------------------------------------------------- +// TASK_FIND_COVER_FROM_BEST_SOUND +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::FindCoverFromBestSound( Vector *pCoverPos ) +{ + CSound *pBestSound; + + pBestSound = GetBestSound(); + + if (pBestSound) + { + // UNDONE: Back away if cover fails? Grunts do this. + return FindCoverPos( pBestSound, pCoverPos ); + } + else + { + DevMsg( 2, "Attempting to find cover from best sound, but best sound not founc.\n" ); + } + + return false; +} + + +//----------------------------------------------------------------------------- +// TASK_FACE_REASONABLE +//----------------------------------------------------------------------------- +float CAI_BaseNPC::CalcReasonableFacing( bool bIgnoreOriginalFacing ) +{ + float flReasonableYaw; + + if( !bIgnoreOriginalFacing && !HasMemory( bits_MEMORY_MOVED_FROM_SPAWN ) && !HasCondition( COND_SEE_ENEMY) ) + { + flReasonableYaw = m_flOriginalYaw; + } + else + { + // If I'm facing a wall, change my original yaw and try to find a good direction to face. + trace_t tr; + Vector forward; + QAngle angles( 0, 0, 0 ); + + float idealYaw = GetMotor()->GetIdealYaw(); + + flReasonableYaw = idealYaw; + + // Try just using the facing we have + const float MIN_DIST = GetReasonableFacingDist(); + float longestTrace = 0; + + // Early out if we're overriding reasonable facing + if ( !MIN_DIST ) + return flReasonableYaw; + + // Otherwise, scan out back and forth until something better is found + const float SLICES = 8.0f; + const float SIZE_SLICE = 360.0 / SLICES; + const int SEARCH_MAX = (int)SLICES / 2; + + float zEye = GetAbsOrigin().z + m_vDefaultEyeOffset.z; // always use standing eye so as to not screw with crouch cover + + for( int i = 0 ; i <= SEARCH_MAX; i++ ) + { + float offset = i * SIZE_SLICE; + for ( int j = -1; j <= 1; j += 2) + { + angles.y = idealYaw + ( offset * j ); + AngleVectors( angles, &forward, NULL, NULL ); + float curTrace; + if( ( curTrace = LineOfSightDist( forward, zEye ) ) > longestTrace && IsValidReasonableFacing(forward, curTrace) ) + { + // Take this one. + flReasonableYaw = angles.y; + longestTrace = curTrace; + } + + if ( longestTrace > MIN_DIST) // found one + break; + + if ( i == 0 || i == SEARCH_MAX) // if trying forwards or backwards, skip the check of the other side... + break; + } + + if ( longestTrace > MIN_DIST ) // found one + break; + } + } + + return flReasonableYaw; +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +float CAI_BaseNPC::GetReasonableFacingDist( void ) +{ + if ( GetTask() && GetTask()->iTask == TASK_FACE_ENEMY ) + { + const float dist = 3.5*12; + if ( GetEnemy() ) + { + float distEnemy = ( GetEnemy()->GetAbsOrigin().AsVector2D() - GetAbsOrigin().AsVector2D() ).Length() - 1.0; + return MIN( distEnemy, dist ); + } + + return dist; + } + return 5*12; +} + +//----------------------------------------------------------------------------- +// TASK_SCRIPT_RUN_TO_TARGET / TASK_SCRIPT_WALK_TO_TARGET / TASK_SCRIPT_CUSTOM_MOVE_TO_TARGET +//----------------------------------------------------------------------------- +void CAI_BaseNPC::StartScriptMoveToTargetTask( int task ) +{ + Activity newActivity; + + if ( m_hTargetEnt == NULL) + { + TaskFail(FAIL_NO_TARGET); + } + else if ( (m_hTargetEnt->GetAbsOrigin() - GetLocalOrigin()).Length() < 1 ) + { + TaskComplete(); + } + else + { + // + // Select the appropriate activity. + // + if ( task == TASK_SCRIPT_WALK_TO_TARGET ) + { + newActivity = ACT_WALK; + } + else if ( task == TASK_SCRIPT_RUN_TO_TARGET ) + { + newActivity = ACT_RUN; + } + else + { + newActivity = GetScriptCustomMoveActivity(); + } + + if ( ( newActivity != ACT_SCRIPT_CUSTOM_MOVE ) && TranslateActivity( newActivity ) == ACT_INVALID ) + { + // This NPC can't do this! + Assert( 0 ); + } + else + { + if (m_hTargetEnt == NULL) + { + TaskFail(FAIL_NO_TARGET); + } + else + { + + AI_NavGoal_t goal( GOALTYPE_TARGETENT, newActivity ); + + if ( GetState() == NPC_STATE_SCRIPT && + ( m_ScriptArrivalActivity != AIN_DEF_ACTIVITY || + m_strScriptArrivalSequence != NULL_STRING ) ) + { + if ( m_ScriptArrivalActivity != AIN_DEF_ACTIVITY ) + { + goal.arrivalActivity = m_ScriptArrivalActivity; + } + else + { + goal.arrivalSequence = LookupSequence( m_strScriptArrivalSequence.ToCStr() ); + } + } + + if (!GetNavigator()->SetGoal( goal, AIN_DISCARD_IF_FAIL )) + { + if ( GetNavigator()->GetNavFailCounter() == 0 ) + { + // no path was built, but OnNavFailed() did something so that next time it may work + DevWarning("%s %s failed Urgent Movement, retrying\n", GetDebugName(), TaskName( task ) ); + return; + } + + // FIXME: scripted sequences don't actually know how to handle failure, but we're failing. This is serious + DevWarning("%s %s failed Urgent Movement, abandoning schedule\n", GetDebugName(), TaskName( task ) ); + TaskFail(FAIL_NO_ROUTE); + } + else + { + GetNavigator()->SetArrivalDirection( m_hTargetEnt->GetAbsAngles() ); + } + } + } + } + + m_ScriptArrivalActivity = AIN_DEF_ACTIVITY; + m_strScriptArrivalSequence = NULL_STRING; + + TaskComplete(); +} + + +//----------------------------------------------------------------------------- +// Start task! +//----------------------------------------------------------------------------- +void CAI_BaseNPC::StartTask( const Task_t *pTask ) +{ + int task = pTask->iTask; + switch ( pTask->iTask ) + { + case TASK_RESET_ACTIVITY: + m_Activity = ACT_RESET; + TaskComplete(); + break; + + case TASK_CREATE_PENDING_WEAPON: + Assert( m_iszPendingWeapon != NULL_STRING ); + GiveWeapon( m_iszPendingWeapon ); + m_iszPendingWeapon = NULL_STRING; + TaskComplete(); + break; + + case TASK_RANDOMIZE_FRAMERATE: + { + float newRate = GetPlaybackRate(); + float percent = pTask->flTaskData / 100.0f; + + newRate += ( newRate * random->RandomFloat(-percent, percent) ); + + SetPlaybackRate(newRate); + + TaskComplete(); + } + break; + + case TASK_DEFER_DODGE: + m_flNextDodgeTime = gpGlobals->curtime + pTask->flTaskData; + TaskComplete(); + break; + + // Default case just completes. Override in sub-classes + // to play sound / animation / or pause + case TASK_ANNOUNCE_ATTACK: + TaskComplete(); + break; + + case TASK_TURN_RIGHT: + StartTurn( -pTask->flTaskData ); + break; + + case TASK_TURN_LEFT: + StartTurn( pTask->flTaskData ); + break; + + case TASK_REMEMBER: + Remember ( (int)pTask->flTaskData ); + TaskComplete(); + break; + + case TASK_FORGET: + Forget ( (int)pTask->flTaskData ); + TaskComplete(); + break; + + case TASK_FIND_HINTNODE: + case TASK_FIND_LOCK_HINTNODE: + { + if (!GetHintNode()) + { + SetHintNode( CAI_HintManager::FindHint( this, HINT_NONE, pTask->flTaskData, 2000 ) ); + } + if (GetHintNode()) + { + TaskComplete(); + } + else + { + TaskFail(FAIL_NO_HINT_NODE); + } + if ( task == TASK_FIND_HINTNODE ) + break; + } + // Fall through on TASK_FIND_LOCK_HINTNODE... + + case TASK_LOCK_HINTNODE: + { + if (!GetHintNode()) + { + TaskFail(FAIL_NO_HINT_NODE); + } + else if( GetHintNode()->Lock(this) ) + { + TaskComplete(); + } + else + { + TaskFail(FAIL_ALREADY_LOCKED); + SetHintNode( NULL ); + } + break; + } + + case TASK_STORE_LASTPOSITION: + m_vecLastPosition = GetLocalOrigin(); + TaskComplete(); + break; + + case TASK_CLEAR_LASTPOSITION: + m_vecLastPosition = vec3_origin; + TaskComplete(); + break; + + case TASK_STORE_POSITION_IN_SAVEPOSITION: + m_vSavePosition = GetLocalOrigin(); + TaskComplete(); + break; + + case TASK_STORE_BESTSOUND_IN_SAVEPOSITION: + { + CSound *pBestSound = GetBestSound(); + if ( pBestSound ) + { + m_vSavePosition = pBestSound->GetSoundOrigin(); + CBaseEntity *pSoundEnt = pBestSound->m_hOwner; + if ( pSoundEnt ) + { + Vector vel; + pSoundEnt->GetVelocity( &vel, NULL ); + // HACKHACK: run away from cars in the right direction + m_vSavePosition += vel * 2; // add in 2 seconds of velocity + } + TaskComplete(); + } + else + { + TaskFail("No Sound!"); + return; + } + } + break; + + case TASK_STORE_BESTSOUND_REACTORIGIN_IN_SAVEPOSITION: + { + CSound *pBestSound = GetBestSound(); + if ( pBestSound ) + { + m_vSavePosition = pBestSound->GetSoundReactOrigin(); + TaskComplete(); + } + else + { + TaskFail("No Sound!"); + return; + } + } + break; + + case TASK_STORE_ENEMY_POSITION_IN_SAVEPOSITION: + if ( GetEnemy() != NULL ) + { + m_vSavePosition = GetEnemy()->GetAbsOrigin(); + TaskComplete(); + } + else + { + TaskFail(FAIL_NO_ENEMY); + } + break; + + case TASK_CLEAR_HINTNODE: + ClearHintNode(pTask->flTaskData); + TaskComplete(); + break; + + case TASK_STOP_MOVING: + if ( ( GetNavigator()->IsGoalSet() && GetNavigator()->IsGoalActive() ) || GetNavType() == NAV_JUMP ) + { + DbgNavMsg( this, "Start TASK_STOP_MOVING\n" ); + if ( pTask->flTaskData == 1 ) + { + DbgNavMsg( this, "Initiating stopping path\n" ); + GetNavigator()->StopMoving( false ); + } + else + { + GetNavigator()->ClearGoal(); + } + + // E3 Hack + if ( HasPoseMoveYaw() ) + { + SetPoseParameter( m_poseMove_Yaw, 0 ); + } + } + else + { + if ( pTask->flTaskData == 1 && GetNavigator()->SetGoalFromStoppingPath() ) + { + DbgNavMsg( this, "Start TASK_STOP_MOVING\n" ); + DbgNavMsg( this, "Initiating stopping path\n" ); + } + else + { + GetNavigator()->ClearGoal(); + SetIdealActivity( GetStoppedActivity() ); + TaskComplete(); + } + } + break; + + case TASK_PLAY_PRIVATE_SEQUENCE: + case TASK_PLAY_PRIVATE_SEQUENCE_FACE_ENEMY: + case TASK_PLAY_SEQUENCE_FACE_ENEMY: + case TASK_PLAY_SEQUENCE_FACE_TARGET: + case TASK_PLAY_SEQUENCE: + SetIdealActivity( (Activity)(int)pTask->flTaskData ); + break; + + case TASK_ADD_GESTURE_WAIT: + { + int iLayer = AddGesture( (Activity)(int)pTask->flTaskData ); + if (iLayer > 0) + { + float flDuration = GetLayerDuration( iLayer ); + SetWait( flDuration ); + } + else + { + TaskFail( "Unable to allocate gesture" ); + } + break; + } + + case TASK_ADD_GESTURE: + { + AddGesture( (Activity)(int)pTask->flTaskData ); + TaskComplete(); + break; + } + + case TASK_PLAY_HINT_ACTIVITY: + if ( GetHintNode()->HintActivityName() != NULL_STRING ) + { + Activity hintActivity = (Activity)CAI_BaseNPC::GetActivityID( STRING(GetHintNode()->HintActivityName()) ); + if ( hintActivity != ACT_INVALID ) + { + SetIdealActivity( GetHintActivity(GetHintNode()->HintType(), hintActivity) ); + } + else + { + int iSequence = LookupSequence(STRING(GetHintNode()->HintActivityName())); + if ( iSequence > ACT_INVALID ) + { + SetSequenceById( iSequence ); // ??? + SetIdealActivity( ACT_DO_NOT_DISTURB ); + } + else + SetIdealActivity( ACT_IDLE ); + } + } + else + { + SetIdealActivity( ACT_IDLE ); + } + break; + + case TASK_SET_SCHEDULE: + if ( !SetSchedule( pTask->flTaskData ) ) + TaskFail(FAIL_SCHEDULE_NOT_FOUND); + break; + + case TASK_FIND_BACKAWAY_FROM_SAVEPOSITION: + { + if ( GetEnemy() != NULL ) + { + Vector backPos; + if ( !GetTacticalServices()->FindBackAwayPos( m_vSavePosition, &backPos ) ) + { + // no place to backaway + TaskFail(FAIL_NO_BACKAWAY_NODE); + } + else + { + if (GetNavigator()->SetGoal( AI_NavGoal_t( backPos, ACT_RUN ) ) ) + { + TaskComplete(); + } + else + { + // no place to backaway + TaskFail(FAIL_NO_ROUTE); + } + } + } + else + { + TaskFail(FAIL_NO_ENEMY); + } + } + break; + + case TASK_FIND_NEAR_NODE_COVER_FROM_ENEMY: + case TASK_FIND_FAR_NODE_COVER_FROM_ENEMY: + case TASK_FIND_NODE_COVER_FROM_ENEMY: + case TASK_FIND_COVER_FROM_ENEMY: + { + bool bNodeCover = ( task != TASK_FIND_COVER_FROM_ENEMY ); + float flMinDistance = ( task == TASK_FIND_FAR_NODE_COVER_FROM_ENEMY ) ? pTask->flTaskData : 0.0; + float flMaxDistance = ( task == TASK_FIND_NEAR_NODE_COVER_FROM_ENEMY ) ? pTask->flTaskData : FLT_MAX; + + if ( FindCoverFromEnemy( bNodeCover, flMinDistance, flMaxDistance ) ) + { + if ( task == TASK_FIND_COVER_FROM_ENEMY ) + m_flMoveWaitFinished = gpGlobals->curtime + pTask->flTaskData; + TaskComplete(); + } + else + TaskFail(FAIL_NO_COVER); + } + break; + + + case TASK_FIND_COVER_FROM_ORIGIN: + { + Vector coverPos; + + if ( GetTacticalServices()->FindCoverPos( GetLocalOrigin(), EyePosition(), 0, CoverRadius(), &coverPos ) ) + { + AI_NavGoal_t goal(coverPos, ACT_RUN, AIN_HULL_TOLERANCE); + GetNavigator()->SetGoal( goal ); + + m_flMoveWaitFinished = gpGlobals->curtime + pTask->flTaskData; + } + else + { + // no coverwhatsoever. + TaskFail(FAIL_NO_COVER); + } + } + + break; + + case TASK_FIND_COVER_FROM_BEST_SOUND: + { + } + break; + + case TASK_FACE_HINTNODE: + + // If the yaw is locked, this function will not act correctly + Assert( GetMotor()->IsYawLocked() == false ); + + GetMotor()->SetIdealYaw( GetHintNode()->Yaw() ); + GetMotor()->SetIdealYaw( CalcReasonableFacing( true ) ); // CalcReasonableFacing() is based on previously set ideal yaw + if ( FacingIdeal() ) + TaskComplete(); + else + SetTurnActivity(); + break; + + case TASK_FACE_LASTPOSITION: + GetMotor()->SetIdealYawToTarget( m_vecLastPosition ); + GetMotor()->SetIdealYaw( CalcReasonableFacing( true ) ); // CalcReasonableFacing() is based on previously set ideal yaw + SetTurnActivity(); + break; + + case TASK_FACE_SAVEPOSITION: + GetMotor()->SetIdealYawToTarget( m_vSavePosition ); + GetMotor()->SetIdealYaw( CalcReasonableFacing( true ) ); // CalcReasonableFacing() is based on previously set ideal yaw + SetTurnActivity(); + break; + + case TASK_FACE_AWAY_FROM_SAVEPOSITION: + GetMotor()->SetIdealYawToTarget( m_vSavePosition, 0, 180.0 ); + GetMotor()->SetIdealYaw( CalcReasonableFacing( true ) ); // CalcReasonableFacing() is based on previously set ideal yaw + SetTurnActivity(); + break; + + case TASK_SET_IDEAL_YAW_TO_CURRENT: + GetMotor()->SetIdealYaw( UTIL_AngleMod( GetLocalAngles().y ) ); + TaskComplete(); + break; + + case TASK_FACE_TARGET: + if ( m_hTargetEnt != NULL ) + { + GetMotor()->SetIdealYawToTarget( m_hTargetEnt->GetAbsOrigin() ); + SetTurnActivity(); + } + else + { + TaskFail(FAIL_NO_TARGET); + } + break; + + case TASK_FACE_PLAYER: + // track head to the client for a while. + SetWait( pTask->flTaskData ); + break; + + case TASK_FACE_ENEMY: + { + Vector vecEnemyLKP = GetEnemyLKP(); + if (!FInAimCone( vecEnemyLKP )) + { + GetMotor()->SetIdealYawToTarget( vecEnemyLKP ); + GetMotor()->SetIdealYaw( CalcReasonableFacing( true ) ); // CalcReasonableFacing() is based on previously set ideal yaw + SetTurnActivity(); + } + else + { + float flReasonableFacing = CalcReasonableFacing( true ); + if ( fabsf( flReasonableFacing - GetMotor()->GetIdealYaw() ) < 1 ) + TaskComplete(); + else + { + GetMotor()->SetIdealYaw( flReasonableFacing ); + SetTurnActivity(); + } + } + break; + } + + case TASK_FACE_IDEAL: + SetTurnActivity(); + break; + + case TASK_FACE_REASONABLE: + GetMotor()->SetIdealYaw( CalcReasonableFacing() ); + SetTurnActivity(); + break; + + case TASK_FACE_PATH: + { + if (!GetNavigator()->IsGoalActive()) + { + DevWarning( 2, "No route to face!\n"); + TaskFail(FAIL_NO_ROUTE); + } + else + { + const float NPC_TRIVIAL_TURN = 15; // (Degrees). Turns this small or smaller, don't bother with a transition. + + GetMotor()->SetIdealYawToTarget( GetNavigator()->GetCurWaypointPos()); + + if( fabs( GetMotor()->DeltaIdealYaw() ) <= NPC_TRIVIAL_TURN ) + { + // This character is already facing the path well enough that + // moving will look fairly natural. Don't bother with a transitional + // turn animation. + TaskComplete(); + break; + } + SetTurnActivity(); + } + } + break; + + // don't do anything. + case TASK_WAIT_PVS: + case TASK_WAIT_INDEFINITE: + break; + + // set a future time that tells us when the wait is over. + case TASK_WAIT: + case TASK_WAIT_FACE_ENEMY: + SetWait( pTask->flTaskData ); + break; + + // set a future time that tells us when the wait is over. + case TASK_WAIT_RANDOM: + case TASK_WAIT_FACE_ENEMY_RANDOM: + SetWait( 0, pTask->flTaskData ); + break; + + case TASK_MOVE_TO_TARGET_RANGE: + case TASK_MOVE_TO_GOAL_RANGE: + { + // Identical tasks, except that target_range uses m_hTargetEnt, + // and Goal range uses the nav goal + CBaseEntity *pTarget = NULL; + if ( task == TASK_MOVE_TO_GOAL_RANGE ) + { + pTarget = GetNavigator()->GetGoalTarget(); + } + if ( !pTarget ) + { + pTarget = m_hTargetEnt.Get(); + } + + if ( pTarget == NULL) + { + TaskFail(FAIL_NO_TARGET); + } + else if ( (pTarget->GetAbsOrigin() - GetLocalOrigin()).Length() < 1 ) + { + TaskComplete(); + } + + if (GetNavigator()->GetGoalType() == GOALTYPE_NONE) + { + TaskComplete(); + GetNavigator()->ClearGoal(); // Clear residual state + } + else + { + // set that we're probably going to stop before the goal + GetNavigator()->SetArrivalDistance( pTask->flTaskData ); + } + + break; + } + + case TASK_WAIT_UNTIL_NO_DANGER_SOUND: + if( !HasCondition( COND_HEAR_DANGER ) ) + { + TaskComplete(); + } + break; + + case TASK_TARGET_PLAYER: + { + CBaseEntity *pPlayer = gEntList.FindEntityByName( NULL, "!player" ); + if ( pPlayer ) + { + SetTarget( pPlayer ); + TaskComplete(); + } + else + TaskFail( FAIL_NO_PLAYER ); + break; + } + + case TASK_SCRIPT_RUN_TO_TARGET: + case TASK_SCRIPT_WALK_TO_TARGET: + case TASK_SCRIPT_CUSTOM_MOVE_TO_TARGET: + StartScriptMoveToTargetTask( pTask->iTask ); + break; + + case TASK_CLEAR_MOVE_WAIT: + m_flMoveWaitFinished = gpGlobals->curtime; + TaskComplete(); + break; + + case TASK_MELEE_ATTACK1: + SetLastAttackTime( gpGlobals->curtime ); + ResetIdealActivity( ACT_MELEE_ATTACK1 ); + break; + + case TASK_MELEE_ATTACK2: + SetLastAttackTime( gpGlobals->curtime ); + ResetIdealActivity( ACT_MELEE_ATTACK2 ); + break; + + case TASK_RANGE_ATTACK1: + SetLastAttackTime( gpGlobals->curtime ); + ResetIdealActivity( ACT_RANGE_ATTACK1 ); + break; + + case TASK_RANGE_ATTACK2: + SetLastAttackTime( gpGlobals->curtime ); + ResetIdealActivity( ACT_RANGE_ATTACK2 ); + break; + + case TASK_RELOAD: + ResetIdealActivity( ACT_RELOAD ); + break; + + case TASK_SPECIAL_ATTACK1: + ResetIdealActivity( ACT_SPECIAL_ATTACK1 ); + break; + + case TASK_SPECIAL_ATTACK2: + ResetIdealActivity( ACT_SPECIAL_ATTACK2 ); + break; + + case TASK_SET_ACTIVITY: + { + Activity goalActivity = (Activity)((int)pTask->flTaskData); + if (goalActivity != ACT_RESET) + { + SetIdealActivity( goalActivity ); + } + else + { + m_Activity = ACT_RESET; + } + break; + } + case TASK_GET_CHASE_PATH_TO_ENEMY: + { + CBaseEntity *pEnemy = GetEnemy(); + if ( !pEnemy ) + { + TaskFail(FAIL_NO_ROUTE); + return; + } + + if ( ( pEnemy->GetAbsOrigin() - GetEnemyLKP() ).LengthSqr() < Square(pTask->flTaskData) ) + { + ChainStartTask( TASK_GET_PATH_TO_ENEMY ); + } + else + { + ChainStartTask( TASK_GET_PATH_TO_ENEMY_LKP ); + } + + if ( !TaskIsComplete() && !HasCondition(COND_TASK_FAILED) ) + TaskFail(FAIL_NO_ROUTE); + break; + } + + case TASK_GET_PATH_TO_ENEMY_LKP: + { + CBaseEntity *pEnemy = GetEnemy(); + if (!pEnemy || IsUnreachable(pEnemy)) + { + TaskFail(FAIL_NO_ROUTE); + return; + } + AI_NavGoal_t goal( GetEnemyLKP() ); + + TranslateNavGoal( pEnemy, goal.dest ); + + if ( GetNavigator()->SetGoal( goal, AIN_CLEAR_TARGET ) ) + { + TaskComplete(); + } + else + { + // no way to get there =( + DevWarning( 2, "GetPathToEnemyLKP failed!!\n" ); + RememberUnreachable(GetEnemy()); + TaskFail(FAIL_NO_ROUTE); + } + break; + } + + case TASK_GET_PATH_TO_INTERACTION_PARTNER: + { + if ( !m_hForcedInteractionPartner || IsUnreachable(m_hForcedInteractionPartner) ) + { + TaskFail(FAIL_NO_ROUTE); + return; + } + + // Calculate the position we need to be at to start the interaction. + CalculateForcedInteractionPosition(); + + AI_NavGoal_t goal( m_vecForcedWorldPosition ); + TranslateNavGoal( m_hForcedInteractionPartner, goal.dest ); + + if ( GetNavigator()->SetGoal( goal, AIN_CLEAR_TARGET ) ) + { + TaskComplete(); + } + else + { + DevWarning( 2, "GetPathToInteractionPartner failed!!\n" ); + RememberUnreachable(m_hForcedInteractionPartner); + TaskFail(FAIL_NO_ROUTE); + } + break; + } + + case TASK_GET_PATH_TO_RANGE_ENEMY_LKP_LOS: + { + if ( GetEnemy() ) + { + // Find out which range to use (either innately or a held weapon) + float flRange = -1.0f; + if ( CapabilitiesGet() & (bits_CAP_INNATE_RANGE_ATTACK1|bits_CAP_INNATE_RANGE_ATTACK2) ) + { + flRange = InnateRange1MaxRange(); + } + else if ( GetActiveWeapon() ) + { + flRange = MAX( GetActiveWeapon()->m_fMaxRange1, GetActiveWeapon()->m_fMaxRange2 ); + } + else + { + // You can't call this task without either innate range attacks or a weapon! + Assert( 0 ); + TaskFail( FAIL_NO_ROUTE ); + } + + // Clamp to the specified range, if supplied + if ( pTask->flTaskData != 0 && pTask->flTaskData < flRange ) + flRange = pTask->flTaskData; + + // For now, just try running straight at enemy + float dist = EnemyDistance( GetEnemy() ); + if ( dist <= flRange || GetNavigator()->SetVectorGoalFromTarget( GetEnemy()->GetAbsOrigin(), dist - flRange ) ) + { + TaskComplete(); + break; + } + } + + TaskFail( FAIL_NO_ROUTE ); + break; + } + + case TASK_GET_PATH_TO_ENEMY_LOS: + case TASK_GET_FLANK_RADIUS_PATH_TO_ENEMY_LOS: + case TASK_GET_FLANK_ARC_PATH_TO_ENEMY_LOS: + case TASK_GET_PATH_TO_ENEMY_LKP_LOS: + { + if ( GetEnemy() == NULL ) + { + TaskFail(FAIL_NO_ENEMY); + return; + } + + AI_PROFILE_SCOPE(CAI_BaseNPC_FindLosToEnemy); + float flMaxRange = 2000; + float flMinRange = 0; + + if ( GetActiveWeapon() ) + { + flMaxRange = MAX( GetActiveWeapon()->m_fMaxRange1, GetActiveWeapon()->m_fMaxRange2 ); + flMinRange = MIN( GetActiveWeapon()->m_fMinRange1, GetActiveWeapon()->m_fMinRange2 ); + } + else if ( CapabilitiesGet() & bits_CAP_INNATE_RANGE_ATTACK1 ) + { + flMaxRange = InnateRange1MaxRange(); + flMinRange = InnateRange1MinRange(); + } + + //Check against NPC's max range + if ( flMaxRange > m_flDistTooFar ) + { + flMaxRange = m_flDistTooFar; + } + + Vector vecEnemy = ( task != TASK_GET_PATH_TO_ENEMY_LKP ) ? GetEnemy()->GetAbsOrigin() : GetEnemyLKP(); + Vector vecEnemyEye = vecEnemy + GetEnemy()->GetViewOffset(); + + Vector posLos; + bool found = false; + + if ( ( task != TASK_GET_FLANK_RADIUS_PATH_TO_ENEMY_LOS ) && ( task != TASK_GET_FLANK_ARC_PATH_TO_ENEMY_LOS ) ) + { + if ( GetTacticalServices()->FindLateralLos( vecEnemyEye, &posLos ) ) + { + float dist = ( posLos - vecEnemyEye ).Length(); + if ( dist < flMaxRange && dist > flMinRange ) + found = true; + } + } + + if ( !found ) + { + FlankType_t eFlankType = FLANKTYPE_NONE; + Vector vecFlankRefPos = vec3_origin; + float flFlankParam = 0; + + if ( task == TASK_GET_FLANK_RADIUS_PATH_TO_ENEMY_LOS ) + { + eFlankType = FLANKTYPE_RADIUS; + vecFlankRefPos = m_vSavePosition; + flFlankParam = pTask->flTaskData; + } + else if ( task == TASK_GET_FLANK_ARC_PATH_TO_ENEMY_LOS ) + { + eFlankType = FLANKTYPE_ARC; + vecFlankRefPos = m_vSavePosition; + flFlankParam = pTask->flTaskData; + } + + if ( GetTacticalServices()->FindLos( vecEnemy, vecEnemyEye, flMinRange, flMaxRange, 1.0, eFlankType, vecFlankRefPos, flFlankParam, &posLos ) ) + { + found = true; + } + } + + if ( !found ) + { + TaskFail( FAIL_NO_SHOOT ); + } + else + { + // else drop into run task to offer an interrupt + m_vInterruptSavePosition = posLos; + } + } + break; + +//================================================== +// TASK_SET_GOAL +//================================================== + + case TASK_SET_GOAL: + + switch ( (int) pTask->flTaskData ) + { + case GOAL_ENEMY: //Enemy + + if ( GetEnemy() == NULL ) + { + TaskFail( FAIL_NO_ENEMY ); + return; + } + + //Setup our stored info + m_vecStoredPathGoal = GetEnemy()->GetAbsOrigin(); + m_nStoredPathType = GOALTYPE_ENEMY; + m_fStoredPathFlags = 0; + m_hStoredPathTarget = GetEnemy(); + GetNavigator()->SetMovementActivity(ACT_RUN); + break; + + case GOAL_ENEMY_LKP: //Enemy's last known position + + if ( GetEnemy() == NULL ) + { + TaskFail( FAIL_NO_ENEMY ); + return; + } + + //Setup our stored info + m_vecStoredPathGoal = GetEnemyLKP(); + m_nStoredPathType = GOALTYPE_LOCATION; + m_fStoredPathFlags = 0; + m_hStoredPathTarget = NULL; + GetNavigator()->SetMovementActivity(ACT_RUN); + break; + + case GOAL_TARGET: //Target entity + + if ( m_hTargetEnt == NULL ) + { + TaskFail( FAIL_NO_TARGET ); + return; + } + + //Setup our stored info + m_vecStoredPathGoal = m_hTargetEnt->GetAbsOrigin(); + m_nStoredPathType = GOALTYPE_TARGETENT; + m_fStoredPathFlags = 0; + m_hStoredPathTarget = m_hTargetEnt; + GetNavigator()->SetMovementActivity(ACT_RUN); + break; + + case GOAL_SAVED_POSITION: //Saved position + + //Setup our stored info + m_vecStoredPathGoal = m_vSavePosition; + m_nStoredPathType = GOALTYPE_LOCATION; + m_fStoredPathFlags = 0; + m_hStoredPathTarget = NULL; + GetNavigator()->SetMovementActivity(ACT_RUN); + break; + } + + TaskComplete(); + + break; + +//================================================== +// TASK_GET_PATH_TO_GOAL +//================================================== + + case TASK_GET_PATH_TO_GOAL: + { + AI_NavGoal_t goal( m_nStoredPathType, + AIN_DEF_ACTIVITY, + AIN_HULL_TOLERANCE, + AIN_DEF_FLAGS, + m_hStoredPathTarget ); + + bool foundPath = false; + + //Find our path + switch ( (int) pTask->flTaskData ) + { + case PATH_TRAVEL: //A land path to our goal + goal.dest = m_vecStoredPathGoal; + foundPath = GetNavigator()->SetGoal( goal ); + break; + + case PATH_LOS: //A path to get LOS to our goal + { + float flMaxRange = 2000.0f; + float flMinRange = 0.0f; + + if ( GetActiveWeapon() ) + { + flMaxRange = MAX( GetActiveWeapon()->m_fMaxRange1, GetActiveWeapon()->m_fMaxRange2 ); + flMinRange = MIN( GetActiveWeapon()->m_fMinRange1, GetActiveWeapon()->m_fMinRange2 ); + } + else if ( CapabilitiesGet() & bits_CAP_INNATE_RANGE_ATTACK1 ) + { + flMaxRange = InnateRange1MaxRange(); + flMinRange = InnateRange1MinRange(); + } + + // Check against NPC's max range + if ( flMaxRange > m_flDistTooFar ) + { + flMaxRange = m_flDistTooFar; + } + + Vector eyePosition = ( m_hStoredPathTarget != NULL ) ? m_hStoredPathTarget->EyePosition() : m_vecStoredPathGoal; + + Vector posLos; + + // See if we've found it + if ( GetTacticalServices()->FindLos( m_vecStoredPathGoal, eyePosition, flMinRange, flMaxRange, 1.0f, &posLos ) ) + { + goal.dest = posLos; + foundPath = GetNavigator()->SetGoal( goal ); + } + else + { + // No LOS to goal + TaskFail( FAIL_NO_SHOOT ); + return; + } + } + + break; + + case PATH_COVER: //Get a path to cover FROM our goal + { + CBaseEntity *pEntity = ( m_hStoredPathTarget == NULL ) ? this : m_hStoredPathTarget; + + //Find later cover first + Vector coverPos; + + if ( GetTacticalServices()->FindLateralCover( pEntity->EyePosition(), 0, &coverPos ) ) + { + AI_NavGoal_t goal( coverPos, ACT_RUN ); + GetNavigator()->SetGoal( goal, AIN_CLEAR_PREVIOUS_STATE ); + + //FIXME: What exactly is this doing internally? + m_flMoveWaitFinished = gpGlobals->curtime + pTask->flTaskData; + TaskComplete(); + return; + } + else + { + //Try any cover + if ( GetTacticalServices()->FindCoverPos( pEntity->GetAbsOrigin(), pEntity->EyePosition(), 0, CoverRadius(), &coverPos ) ) + { + //If we've found it, find a safe route there + AI_NavGoal_t coverGoal( GOALTYPE_COVER, + coverPos, + ACT_RUN, + AIN_HULL_TOLERANCE, + AIN_DEF_FLAGS, + m_hStoredPathTarget ); + + foundPath = GetNavigator()->SetGoal( goal ); + + m_flMoveWaitFinished = gpGlobals->curtime + pTask->flTaskData; + } + else + { + TaskFail( FAIL_NO_COVER ); + } + } + } + + break; + } + + //Now validate our try + if ( foundPath ) + { + TaskComplete(); + } + else + { + TaskFail( FAIL_NO_ROUTE ); + } + } + break; + + case TASK_GET_PATH_TO_ENEMY: + { + if (IsUnreachable(GetEnemy())) + { + TaskFail(FAIL_NO_ROUTE); + return; + } + + CBaseEntity *pEnemy = GetEnemy(); + + if ( pEnemy == NULL ) + { + TaskFail(FAIL_NO_ENEMY); + return; + } + + if ( GetNavigator()->SetGoal( GOALTYPE_ENEMY ) ) + { + TaskComplete(); + } + else + { + // no way to get there =( + DevWarning( 2, "GetPathToEnemy failed!!\n" ); + RememberUnreachable(GetEnemy()); + TaskFail(FAIL_NO_ROUTE); + } + break; + } + case TASK_GET_PATH_TO_ENEMY_CORPSE: + { + Vector forward; + AngleVectors( GetLocalAngles(), &forward ); + Vector vecEnemyLKP = GetEnemyLKP(); + + GetNavigator()->SetGoal( vecEnemyLKP - forward * 64, AIN_CLEAR_TARGET); + } + break; + + case TASK_GET_PATH_TO_PLAYER: + { + CBaseEntity *pPlayer = gEntList.FindEntityByName( NULL, "!player" ); + + AI_NavGoal_t goal; + + goal.type = GOALTYPE_LOCATION; + goal.dest = pPlayer->WorldSpaceCenter(); + goal.pTarget = pPlayer; + + GetNavigator()->SetGoal( goal ); + break; + } + + case TASK_GET_PATH_TO_SAVEPOSITION_LOS: + { + if ( GetEnemy() == NULL ) + { + TaskFail(FAIL_NO_ENEMY); + return; + } + + float flMaxRange = 2000; + float flMinRange = 0; + if ( GetActiveWeapon() ) + { + flMaxRange = MAX(GetActiveWeapon()->m_fMaxRange1,GetActiveWeapon()->m_fMaxRange2); + flMinRange = MIN(GetActiveWeapon()->m_fMinRange1,GetActiveWeapon()->m_fMinRange2); + } + else if ( CapabilitiesGet() & bits_CAP_INNATE_RANGE_ATTACK1 ) + { + flMaxRange = InnateRange1MaxRange(); + flMinRange = InnateRange1MinRange(); + } + + // Check against NPC's max range + if (flMaxRange > m_flDistTooFar) + { + flMaxRange = m_flDistTooFar; + } + + Vector posLos; + + if (GetTacticalServices()->FindLos(m_vSavePosition,m_vSavePosition, flMinRange, flMaxRange, 1.0, &posLos)) + { + GetNavigator()->SetGoal( AI_NavGoal_t( posLos, ACT_RUN, AIN_HULL_TOLERANCE ) ); + } + else + { + // no coverwhatsoever. + TaskFail(FAIL_NO_SHOOT); + } + break; + } + + case TASK_GET_PATH_TO_TARGET_WEAPON: + { + // Finds the nearest node within the leniency distances, + // whether the node can see the target or not. + const float XY_LENIENCY = 64.0; + const float Z_LENIENCY = 72.0; + + if (m_hTargetEnt == NULL) + { + TaskFail(FAIL_NO_TARGET); + } + else + { + // Since this weapon MAY be on a table, we find the nearest node without verifying + // line-of-sight, since weapons on the table will not be able to see nodes very nearby. + int node = GetNavigator()->GetNetwork()->NearestNodeToPoint( this, m_hTargetEnt->GetAbsOrigin(), false ); + CAI_Node *pNode = GetNavigator()->GetNetwork()->GetNode( node ); + + if( !pNode ) + { + TaskFail( FAIL_NO_ROUTE ); + break; + } + + bool bHasPath = true; + Vector vecNodePos; + + vecNodePos = pNode->GetPosition( GetHullType() ); + + float flDistZ; + flDistZ = fabs( vecNodePos.z - m_hTargetEnt->GetAbsOrigin().z ); + if( flDistZ > Z_LENIENCY ) + { + // The gun is too far away from its nearest node on the Z axis. + TaskFail( "Target not within Z_LENIENCY!\n"); + CBaseCombatWeapon *pWeapon = dynamic_cast<CBaseCombatWeapon*>( m_hTargetEnt.Get() ); + if( pWeapon ) + { + // Lock this weapon for a long time so no one else tries to get it. + pWeapon->Lock( 30.0f, pWeapon ); + break; + } + } + + if( flDistZ >= 16.0 ) + { + // The gun is higher or lower, but it's within reach. (probably on a table). + float flDistXY = ( vecNodePos - m_hTargetEnt->GetAbsOrigin() ).Length2D(); + + // This means we have to stand on the nearest node and still be able to + // reach the gun. + if( flDistXY > XY_LENIENCY ) + { + TaskFail( "Target not within XY_LENIENCY!\n" ); + CBaseCombatWeapon *pWeapon = dynamic_cast<CBaseCombatWeapon*>( m_hTargetEnt.Get() ); + if( pWeapon ) + { + // Lock this weapon for a long time so no one else tries to get it. + pWeapon->Lock( 30.0f, pWeapon ); + break; + } + } + + AI_NavGoal_t goal( vecNodePos ); + goal.pTarget = m_hTargetEnt; + bHasPath = GetNavigator()->SetGoal( goal ); + } + else + { + // The gun is likely just lying on the floor. Just pick it up. + AI_NavGoal_t goal( m_hTargetEnt->GetAbsOrigin() ); + goal.pTarget = m_hTargetEnt; + bHasPath = GetNavigator()->SetGoal( goal ); + } + + if( !bHasPath ) + { + CBaseCombatWeapon *pWeapon = dynamic_cast<CBaseCombatWeapon*>( m_hTargetEnt.Get() ); + if( pWeapon ) + { + // Lock this weapon for a long time so no one else tries to get it. + pWeapon->Lock( 15.0f, pWeapon ); + } + } + } + } + break; + + case TASK_GET_PATH_TO_TARGET: + { + if (m_hTargetEnt == NULL) + { + TaskFail(FAIL_NO_TARGET); + } + else + { + AI_NavGoal_t goal( static_cast<const Vector&>(m_hTargetEnt->EyePosition()) ); + goal.pTarget = m_hTargetEnt; + GetNavigator()->SetGoal( goal ); + } + break; + } + + case TASK_GET_PATH_TO_HINTNODE:// for active idles! + { + if (!GetHintNode()) + { + TaskFail(FAIL_NO_HINT_NODE); + } + else + { + Vector vHintPos; + GetHintNode()->GetPosition(this, &vHintPos); + + GetNavigator()->SetGoal( AI_NavGoal_t( vHintPos, ACT_RUN ) ); + if ( pTask->flTaskData == 0 ) + GetNavigator()->SetArrivalDirection( GetHintNode()->GetDirection() ); + if ( GetHintNode()->HintActivityName() != NULL_STRING ) + { + Activity hintActivity = (Activity)CAI_BaseNPC::GetActivityID( STRING(GetHintNode()->HintActivityName()) ); + if ( hintActivity != ACT_INVALID ) + { + GetNavigator()->SetArrivalActivity( GetHintActivity(GetHintNode()->HintType(), hintActivity) ); + } + else + { + int iSequence = LookupSequence(STRING(GetHintNode()->HintActivityName()));; + if ( iSequence != ACT_INVALID ) + GetNavigator()->SetArrivalSequence( iSequence ); + } + + } + } + break; + } + + case TASK_GET_PATH_TO_COMMAND_GOAL: + { + if (!GetNavigator()->SetGoal( m_vecCommandGoal )) + { + OnMoveToCommandGoalFailed(); + TaskFail(FAIL_NO_ROUTE); + } + break; + } + + case TASK_MARK_COMMAND_GOAL_POS: + // Start watching my position to detect whether another AI process has moved me from my mark. + m_CommandMoveMonitor.SetMark( this, COMMAND_GOAL_TOLERANCE ); + TaskComplete(); + break; + + case TASK_CLEAR_COMMAND_GOAL: + m_vecCommandGoal = vec3_invalid; + TaskComplete(); + break; + + case TASK_GET_PATH_TO_LASTPOSITION: + { + if (!GetNavigator()->SetGoal( m_vecLastPosition )) + { + TaskFail(FAIL_NO_ROUTE); + } + else + { + GetNavigator()->SetGoalTolerance( 48 ); + } + break; + } + + case TASK_GET_PATH_TO_SAVEPOSITION: + { + GetNavigator()->SetGoal( m_vSavePosition ); + break; + } + + + case TASK_GET_PATH_TO_RANDOM_NODE: // Task argument is lenth of path to build + { + if ( GetNavigator()->SetRandomGoal( pTask->flTaskData ) ) + TaskComplete(); + else + TaskFail(FAIL_NO_REACHABLE_NODE); + + break; + } + + case TASK_GET_PATH_TO_BESTSOUND: + { + + CSound *pSound = GetBestSound(); + if (!pSound) + { + TaskFail(FAIL_NO_SOUND); + } + else + { + GetNavigator()->SetGoal( pSound->GetSoundReactOrigin() ); + } + break; + } + case TASK_GET_PATH_TO_BESTSCENT: + { + + CSound *pScent = GetBestScent(); + if (!pScent) + { + TaskFail(FAIL_NO_SCENT); + } + else + { + GetNavigator()->SetGoal( pScent->GetSoundOrigin() ); + } + break; + } + + case TASK_GET_PATH_AWAY_FROM_BEST_SOUND: + { + CSound *pBestSound = GetBestSound(); + if ( !pBestSound ) + { + TaskFail("No Sound!"); + break; + } + + GetMotor()->SetIdealYawToTarget( pBestSound->GetSoundOrigin() ); + ChainStartTask( TASK_MOVE_AWAY_PATH, pTask->flTaskData ); + LockBestSound(); + break; + } + + case TASK_MOVE_AWAY_PATH: + { + // Drop into run task to support interrupt + DesireStand(); + } + break; + + case TASK_WEAPON_RUN_PATH: + case TASK_ITEM_RUN_PATH: + GetNavigator()->SetMovementActivity(ACT_RUN); + break; + + case TASK_RUN_PATH: + { + // UNDONE: This is in some default AI and some NPCs can't run? -- walk instead? + if ( TranslateActivity( ACT_RUN ) != ACT_INVALID ) + { + GetNavigator()->SetMovementActivity( ACT_RUN ); + } + else + { + GetNavigator()->SetMovementActivity(ACT_WALK); + } + // Cover is void once I move + Forget( bits_MEMORY_INCOVER ); + TaskComplete(); + break; + } + + case TASK_WALK_PATH_FOR_UNITS: + { + GetNavigator()->SetMovementActivity(ACT_WALK); + break; + } + + case TASK_RUN_PATH_FOR_UNITS: + { + GetNavigator()->SetMovementActivity(ACT_RUN); + break; + } + + case TASK_WALK_PATH: + { + bool bIsFlying = (GetMoveType() == MOVETYPE_FLY) || (GetMoveType() == MOVETYPE_FLYGRAVITY); + if ( bIsFlying && ( TranslateActivity( ACT_FLY ) != ACT_INVALID) ) + { + GetNavigator()->SetMovementActivity(ACT_FLY); + } + else if ( TranslateActivity( ACT_WALK ) != ACT_INVALID ) + { + GetNavigator()->SetMovementActivity(ACT_WALK); + } + else + { + GetNavigator()->SetMovementActivity(ACT_RUN); + } + // Cover is void once I move + Forget( bits_MEMORY_INCOVER ); + TaskComplete(); + break; + } + case TASK_WALK_PATH_WITHIN_DIST: + { + GetNavigator()->SetMovementActivity(ACT_WALK); + // set that we're probably going to stop before the goal + GetNavigator()->SetArrivalDistance( pTask->flTaskData ); + break; + } + case TASK_RUN_PATH_WITHIN_DIST: + { + GetNavigator()->SetMovementActivity(ACT_RUN); + // set that we're probably going to stop before the goal + GetNavigator()->SetArrivalDistance( pTask->flTaskData ); + break; + } + case TASK_RUN_PATH_FLEE: + { + Vector vecDiff; + vecDiff = GetLocalOrigin() - GetNavigator()->GetGoalPos(); + + if( vecDiff.Length() <= pTask->flTaskData ) + { + GetNavigator()->StopMoving(); + TaskFail("Flee path shorter than task parameter"); + } + else + { + GetNavigator()->SetMovementActivity(ACT_RUN); + } + + break; + } + case TASK_WALK_PATH_TIMED: + { + GetNavigator()->SetMovementActivity(ACT_WALK); + SetWait( pTask->flTaskData ); + break; + } + case TASK_RUN_PATH_TIMED: + { + GetNavigator()->SetMovementActivity(ACT_RUN); + SetWait( pTask->flTaskData ); + break; + } + case TASK_STRAFE_PATH: + { + Vector2D vec2DirToPoint; + Vector2D vec2RightSide; + + // to start strafing, we have to first figure out if the target is on the left side or right side + Vector right; + AngleVectors( GetLocalAngles(), NULL, &right, NULL ); + + vec2DirToPoint = ( GetNavigator()->GetCurWaypointPos() - GetLocalOrigin() ).AsVector2D(); + Vector2DNormalize(vec2DirToPoint); + vec2RightSide = right.AsVector2D(); + Vector2DNormalize(vec2RightSide); + + if ( DotProduct2D ( vec2DirToPoint, vec2RightSide ) > 0 ) + { + // strafe right + GetNavigator()->SetMovementActivity(ACT_STRAFE_RIGHT); + } + else + { + // strafe left + GetNavigator()->SetMovementActivity(ACT_STRAFE_LEFT); + } + TaskComplete(); + break; + } + + case TASK_WAIT_FOR_MOVEMENT_STEP: + { + if(!GetNavigator()->IsGoalActive()) + { + TaskComplete(); + return; + } + + if ( IsActivityFinished() ) + { + TaskComplete(); + return; + } + ValidateNavGoal(); + break; + } + + case TASK_WAIT_FOR_MOVEMENT: + { + if (GetNavigator()->GetGoalType() == GOALTYPE_NONE) + { + TaskComplete(); + GetNavigator()->ClearGoal(); // Clear residual state + } + else if (!GetNavigator()->IsGoalActive()) + { + SetIdealActivity( GetStoppedActivity() ); + } + else + { + // Check validity of goal type + ValidateNavGoal(); + } + break; + } + case TASK_SMALL_FLINCH: + { + Remember(bits_MEMORY_FLINCHED); + SetIdealActivity( GetFlinchActivity( false, false ) ); + m_flNextFlinchTime = gpGlobals->curtime + random->RandomFloat( 3, 5 ); + break; + } + case TASK_BIG_FLINCH: + { + Remember(bits_MEMORY_FLINCHED); + SetIdealActivity( GetFlinchActivity( true, false ) ); + m_flNextFlinchTime = gpGlobals->curtime + random->RandomFloat( 3, 5 ); + break; + } + case TASK_DIE: + { + GetNavigator()->StopMoving(); + SetIdealActivity( GetDeathActivity() ); + m_lifeState = LIFE_DYING; + + break; + } + case TASK_SOUND_WAKE: + { + AlertSound(); + TaskComplete(); + break; + } + case TASK_SOUND_DIE: + { + CTakeDamageInfo info; + DeathSound( info ); + TaskComplete(); + break; + } + case TASK_SOUND_IDLE: + { + IdleSound(); + TaskComplete(); + break; + } + case TASK_SOUND_PAIN: + { + CTakeDamageInfo info; + PainSound( info ); + TaskComplete(); + break; + } + case TASK_SOUND_ANGRY: + { + // sounds are complete as soon as we get here, cause we've already played them. + DevMsg( 2, "SOUND\n" ); + TaskComplete(); + break; + } + case TASK_SPEAK_SENTENCE: + { + SpeakSentence(pTask->flTaskData); + TaskComplete(); + break; + } + case TASK_WAIT_FOR_SPEAK_FINISH: + { + if ( !GetExpresser() ) + TaskComplete(); + else + { + // Are we waiting for our speech to end? Or for the mutex to be free? + if ( pTask->flTaskData ) + { + // Waiting for our speech to end + if ( GetExpresser()->CanSpeakAfterMyself() ) + { + TaskComplete(); + } + } + else + { + // Waiting for the speech & the delay afterwards + if ( !GetExpresser()->IsSpeaking() ) + { + TaskComplete(); + } + } + break; + + } + break; + } + case TASK_WAIT_FOR_SCRIPT: + { + if ( !m_hCine ) + { + DevMsg( "Scripted sequence destroyed while in use\n" ); + TaskFail( FAIL_SCHEDULE_NOT_FOUND ); + break; + } + + break; + } + case TASK_PUSH_SCRIPT_ARRIVAL_ACTIVITY: + { + if ( !m_hCine ) + { + DevMsg( "Scripted sequence destroyed while in use\n" ); + TaskFail( FAIL_SCHEDULE_NOT_FOUND ); + break; + } + + string_t iszArrivalText; + + if ( m_hCine->m_iszEntry != NULL_STRING ) + { + iszArrivalText = m_hCine->m_iszEntry; + } + else if ( m_hCine->m_iszPlay != NULL_STRING ) + { + iszArrivalText = m_hCine->m_iszPlay; + } + else if ( m_hCine->m_iszPostIdle != NULL_STRING ) + { + iszArrivalText = m_hCine->m_iszPostIdle; + } + else + iszArrivalText = NULL_STRING; + + m_ScriptArrivalActivity = AIN_DEF_ACTIVITY; + m_strScriptArrivalSequence = NULL_STRING; + + if ( iszArrivalText != NULL_STRING ) + { + m_ScriptArrivalActivity = (Activity)GetActivityID( STRING( iszArrivalText ) ); + if ( m_ScriptArrivalActivity == ACT_INVALID ) + m_strScriptArrivalSequence = iszArrivalText; + } + + TaskComplete(); + break; + } + + case TASK_PLAY_SCRIPT: + { + // Throw away any stopping paths we have saved, because we + // won't be able to resume them after the sequence. + GetNavigator()->IgnoreStoppingPath(); + + if ( HasMovement( GetSequence() ) || m_hCine->m_bIgnoreGravity ) + { + AddFlag( FL_FLY ); + SetGroundEntity( NULL ); + } + + if (m_hCine) + { + m_hCine->SynchronizeSequence( this ); + } + // + // Start playing a scripted sequence. + // + m_scriptState = SCRIPT_PLAYING; + break; + } + case TASK_PLAY_SCRIPT_POST_IDLE: + { + // + // Start playing a scripted post idle. + // + m_scriptState = SCRIPT_POST_IDLE; + break; + } + + // This is the first task of every schedule driven by a scripted_sequence. + // Delay starting the sequence until all actors have hit their marks. + case TASK_PRE_SCRIPT: + { + if ( !ai_task_pre_script.GetBool() ) + { + TaskComplete(); + } + else if ( !m_hCine ) + { + TaskComplete(); + //DevMsg( "Scripted sequence destroyed while in use\n" ); + //TaskFail( FAIL_SCHEDULE_NOT_FOUND ); + } + else + { + m_hCine->DelayStart( true ); + TaskComplete(); + } + break; + } + + case TASK_ENABLE_SCRIPT: + { + // + // Start waiting to play a script. Play the script's pre idle animation if one + // is specified, otherwise just go to our default idle activity. + // + if ( m_hCine->m_iszPreIdle != NULL_STRING ) + { + m_hCine->StartSequence( ( CAI_BaseNPC * )this, m_hCine->m_iszPreIdle, false ); + if ( FStrEq( STRING( m_hCine->m_iszPreIdle ), STRING( m_hCine->m_iszPlay ) ) ) + { + m_flPlaybackRate = 0; + } + } + else if ( m_scriptState != SCRIPT_CUSTOM_MOVE_TO_MARK ) + { + // FIXME: too many ss assume its safe to leave the npc is whatever sequence they were in before, so only slam their activity + // if they're playing a recognizable movement animation + // +#ifdef HL2_EPISODIC + // dvs: Check current activity rather than ideal activity. Since scripted NPCs early out in MaintainActivity, + // they'll never reach their ideal activity if it's different from their current activity. + if ( GetActivity() == ACT_WALK || + GetActivity() == ACT_RUN || + GetActivity() == ACT_WALK_AIM || + GetActivity() == ACT_RUN_AIM ) + { + SetActivity( ACT_IDLE ); + } +#else + if ( GetIdealActivity() == ACT_WALK || + GetIdealActivity() == ACT_RUN || + GetIdealActivity() == ACT_WALK_AIM || + GetIdealActivity() == ACT_RUN_AIM ) + { + SetActivity( ACT_IDLE ); + } +#endif // HL2_EPISODIC + } + break; + } + case TASK_PLANT_ON_SCRIPT: + { + if ( m_hTargetEnt != NULL ) + { + SetLocalOrigin( m_hTargetEnt->GetAbsOrigin() ); // Plant on target + } + + TaskComplete(); + break; + } + case TASK_FACE_SCRIPT: + { + if ( m_hTargetEnt != NULL ) + { + GetMotor()->SetIdealYaw( UTIL_AngleMod( m_hTargetEnt->GetLocalAngles().y ) ); + } + + if ( m_scriptState != SCRIPT_CUSTOM_MOVE_TO_MARK ) + { + SetTurnActivity(); + + // dvs: HACK: MaintainActivity won't do anything while scripted, so go straight there. + SetActivity( GetIdealActivity() ); + } + + GetNavigator()->StopMoving(); + break; + } + + case TASK_PLAY_SCENE: + { + // inside a scene with movement and sequence commands + break; + } + + + case TASK_SUGGEST_STATE: + { + SetIdealState( (NPC_STATE)(int)pTask->flTaskData ); + TaskComplete(); + break; + } + + case TASK_SET_FAIL_SCHEDULE: + m_failSchedule = (int)pTask->flTaskData; + TaskComplete(); + break; + + case TASK_SET_TOLERANCE_DISTANCE: + GetNavigator()->SetGoalTolerance( (int)pTask->flTaskData ); + TaskComplete(); + break; + + case TASK_SET_ROUTE_SEARCH_TIME: + GetNavigator()->SetMaxRouteRebuildTime( (int)pTask->flTaskData ); + TaskComplete(); + break; + + case TASK_CLEAR_FAIL_SCHEDULE: + m_failSchedule = SCHED_NONE; + TaskComplete(); + break; + + case TASK_WEAPON_FIND: + { + m_hTargetEnt = Weapon_FindUsable( Vector(1000,1000,1000) ); + if (m_hTargetEnt) + { + TaskComplete(); + } + else + { + TaskFail(FAIL_ITEM_NO_FIND); + } + } + break; + + case TASK_ITEM_PICKUP: + { + SetIdealActivity( ACT_PICKUP_GROUND ); + } + break; + + case TASK_WEAPON_PICKUP: + { + if( GetActiveWeapon() ) + { + Weapon_Drop( GetActiveWeapon() ); + } + + if( GetTarget() ) + { + CBaseCombatWeapon *pWeapon = dynamic_cast<CBaseCombatWeapon*>(GetTarget()); + if( pWeapon ) + { + if( Weapon_IsOnGround( pWeapon ) ) + { + // Squat down + SetIdealActivity( ACT_PICKUP_GROUND ); + } + else + { + // Reach and take this weapon from rack or shelf. + SetIdealActivity( ACT_PICKUP_RACK ); + } + + return; + } + } + + TaskFail("Weapon went away!\n"); + } + break; + + case TASK_WEAPON_CREATE: + { + if( !GetActiveWeapon() && GetTarget() ) + { + // Create a copy of the weapon this NPC is trying to pick up. + CBaseCombatWeapon *pTargetWeapon = dynamic_cast<CBaseCombatWeapon*>(GetTarget()); + + if( pTargetWeapon ) + { + CBaseCombatWeapon *pWeapon = Weapon_Create( pTargetWeapon->GetClassname() ); + if ( pWeapon ) + { + Weapon_Equip( pWeapon ); + } + } + } + SetTarget( NULL ); + TaskComplete(); + } + break; + + case TASK_USE_SMALL_HULL: + { + SetHullSizeSmall(); + TaskComplete(); + } + break; + + case TASK_FALL_TO_GROUND: + // Set a wait time to try to force a ground ent. + SetWait(4); + break; + + case TASK_WANDER: + { + // This task really uses 2 parameters, so we have to extract + // them from a single integer. To send both parameters, the + // formula is MIN_DIST * 10000 + MAX_DIST + { + int iMinDist, iMaxDist, iParameter; + + iParameter = pTask->flTaskData; + + iMinDist = iParameter / 10000; + iMaxDist = iParameter - (iMinDist * 10000); + + if ( GetNavigator()->SetWanderGoal( iMinDist, iMaxDist ) ) + TaskComplete(); + else + TaskFail(FAIL_NO_REACHABLE_NODE); + } + } + break; + + case TASK_FREEZE: + m_flPlaybackRate = 0; + break; + + case TASK_GATHER_CONDITIONS: + GatherConditions(); + TaskComplete(); + break; + + case TASK_IGNORE_OLD_ENEMIES: + m_flAcceptableTimeSeenEnemy = gpGlobals->curtime; + if ( GetEnemy() && GetEnemyLastTimeSeen() < m_flAcceptableTimeSeenEnemy ) + { + CBaseEntity *pNewEnemy = BestEnemy(); + + Assert( pNewEnemy != GetEnemy() ); + + if( pNewEnemy != NULL ) + { + // New enemy! Clear the timers and set conditions. + SetEnemy( pNewEnemy ); + SetState( NPC_STATE_COMBAT ); + } + else + { + SetEnemy( NULL ); + ClearAttackConditions(); + } + } + TaskComplete(); + break; + + case TASK_ADD_HEALTH: + TakeHealth( (int)pTask->flTaskData, DMG_GENERIC ); + TaskComplete(); + break; + + default: + { + DevMsg( "No StartTask entry for %s\n", TaskName( task ) ); + } + break; + } +} + +void CAI_BaseNPC::StartTaskOverlay() +{ + if ( IsCurTaskContinuousMove() ) + { + if ( ShouldMoveAndShoot() ) + { + m_MoveAndShootOverlay.StartShootWhileMove(); + } + else + { + m_MoveAndShootOverlay.NoShootWhileMove(); + } + } +} + + +//----------------------------------------------------------------------------- +// TASK_DIE. +//----------------------------------------------------------------------------- +void CAI_BaseNPC::RunDieTask() +{ + AutoMovement(); + + if ( IsActivityFinished() && GetCycle() >= 1.0f ) + { + m_lifeState = LIFE_DEAD; + + SetThink ( NULL ); + StopAnimation(); + + if ( !BBoxFlat() ) + { + // a bit of a hack. If a corpses' bbox is positioned such that being left solid so that it can be attacked will + // block the player on a slope or stairs, the corpse is made nonsolid. +// SetSolid( SOLID_NOT ); + UTIL_SetSize ( this, Vector ( -4, -4, 0 ), Vector ( 4, 4, 1 ) ); + } + else // !!!HACKHACK - put NPC in a thin, wide bounding box until we fix the solid type/bounding volume problem + UTIL_SetSize ( this, WorldAlignMins(), Vector ( WorldAlignMaxs().x, WorldAlignMaxs().y, WorldAlignMins().z + 1 ) ); + } +} + + +//----------------------------------------------------------------------------- +// TASK_RANGE_ATTACK1 / TASK_RANGE_ATTACK2 / etc. +//----------------------------------------------------------------------------- +void CAI_BaseNPC::RunAttackTask( int task ) +{ + AutoMovement( ); + + Vector vecEnemyLKP = GetEnemyLKP(); + + // If our enemy was killed, but I'm not done animating, the last known position comes + // back as the origin and makes the me face the world origin if my attack schedule + // doesn't break when my enemy dies. (sjb) + if( vecEnemyLKP != vec3_origin ) + { + if ( ( task == TASK_RANGE_ATTACK1 || task == TASK_RELOAD ) && + ( CapabilitiesGet() & bits_CAP_AIM_GUN ) && + FInAimCone( vecEnemyLKP ) ) + { + // Arms will aim, so leave body yaw as is + GetMotor()->SetIdealYawAndUpdate( GetMotor()->GetIdealYaw(), AI_KEEP_YAW_SPEED ); + } + else + { + GetMotor()->SetIdealYawToTargetAndUpdate( vecEnemyLKP, AI_KEEP_YAW_SPEED ); + } + } + + if ( IsActivityFinished() ) + { + if ( task == TASK_RELOAD && GetShotRegulator() ) + { + GetShotRegulator()->Reset( false ); + } + + TaskComplete(); + } +} + + +//========================================================= +// RunTask +//========================================================= +void CAI_BaseNPC::RunTask( const Task_t *pTask ) +{ + VPROF_BUDGET( "CAI_BaseNPC::RunTask", VPROF_BUDGETGROUP_NPCS ); + switch ( pTask->iTask ) + { + case TASK_GET_PATH_TO_RANDOM_NODE: + { + break; + } + case TASK_TURN_RIGHT: + case TASK_TURN_LEFT: + { + // If the yaw is locked, this function will not act correctly + Assert( GetMotor()->IsYawLocked() == false ); + + GetMotor()->UpdateYaw(); + + if ( FacingIdeal() ) + { + TaskComplete(); + } + break; + } + + case TASK_PLAY_PRIVATE_SEQUENCE_FACE_ENEMY: + case TASK_PLAY_SEQUENCE_FACE_ENEMY: + case TASK_PLAY_SEQUENCE_FACE_TARGET: + { + CBaseEntity *pTarget; + + if ( pTask->iTask == TASK_PLAY_SEQUENCE_FACE_TARGET ) + pTarget = m_hTargetEnt; + else + pTarget = GetEnemy(); + if ( pTarget ) + { + GetMotor()->SetIdealYawAndUpdate( pTarget->GetAbsOrigin() - GetLocalOrigin() , AI_KEEP_YAW_SPEED ); + } + + if ( IsActivityFinished() ) + { + TaskComplete(); + } + } + break; + + case TASK_PLAY_HINT_ACTIVITY: + { + if (!GetHintNode()) + { + TaskFail(FAIL_NO_HINT_NODE); + } + + // Put a debugging check in here + if (GetHintNode()->User() != this) + { + DevMsg("Hint node (%s) being used by non-owner!\n",GetHintNode()->GetDebugName()); + } + + if ( IsActivityFinished() ) + { + TaskComplete(); + } + + break; + } + + case TASK_STOP_MOVING: + { + if ( pTask->flTaskData == 1 ) + { + ChainRunTask( TASK_WAIT_FOR_MOVEMENT ); + if ( GetTaskStatus() == TASKSTATUS_COMPLETE ) + { + DbgNavMsg( this, "TASK_STOP_MOVING Complete\n" ); + } + } + else + { + // if they're jumping, wait until they land + if (GetNavType() == NAV_JUMP) + { + if (GetFlags() & FL_ONGROUND) + { + DbgNavMsg( this, "Jump landed\n" ); + SetNavType( NAV_GROUND ); // this assumes that NAV_JUMP only happens with npcs that use NAV_GROUND as base movement + } + else if (GetSmoothedVelocity().Length() > 0.01) // use an EPSILON damnit!! + { + // wait until you land + break; + } + else + { + DbgNavMsg( this, "Jump stuck\n" ); + // stopped and stuck! + SetNavType( NAV_GROUND ); + TaskFail( FAIL_STUCK_ONTOP ); + } + } + + // @TODO (toml 10-30-02): this is unacceptable, but needed until navigation can handle commencing + // a navigation while in the middle of a climb + if (GetNavType() == NAV_CLIMB) + { + // wait until you reach the end + break; + } + + DbgNavMsg( this, "TASK_STOP_MOVING Complete\n" ); + SetIdealActivity( GetStoppedActivity() ); + + TaskComplete(); + } + break; + } + + case TASK_PLAY_SEQUENCE: + case TASK_PLAY_PRIVATE_SEQUENCE: + { + AutoMovement( ); + if ( IsActivityFinished() ) + { + TaskComplete(); + } + break; + } + + case TASK_ADD_GESTURE_WAIT: + { + if ( IsWaitFinished() ) + { + TaskComplete(); + } + break; + } + + case TASK_SET_ACTIVITY: + { + if ( IsActivityStarted() ) + { + TaskComplete(); + } + } + break; + + case TASK_FACE_ENEMY: + { + // If the yaw is locked, this function will not act correctly + Assert( GetMotor()->IsYawLocked() == false ); + + Vector vecEnemyLKP = GetEnemyLKP(); + if (!FInAimCone( vecEnemyLKP )) + { + GetMotor()->SetIdealYawToTarget( vecEnemyLKP ); + GetMotor()->SetIdealYaw( CalcReasonableFacing( true ) ); // CalcReasonableFacing() is based on previously set ideal yaw + } + else + { + float flReasonableFacing = CalcReasonableFacing( true ); + if ( fabsf( flReasonableFacing - GetMotor()->GetIdealYaw() ) > 1 ) + GetMotor()->SetIdealYaw( flReasonableFacing ); + } + + GetMotor()->UpdateYaw(); + + if ( FacingIdeal() ) + { + TaskComplete(); + } + break; + } + case TASK_FACE_PLAYER: + { + // Get edict for one player + CBasePlayer *pPlayer = AI_GetSinglePlayer(); + if ( pPlayer ) + { + GetMotor()->SetIdealYawToTargetAndUpdate( pPlayer->GetAbsOrigin(), AI_KEEP_YAW_SPEED ); + SetTurnActivity(); + if ( IsWaitFinished() && GetMotor()->DeltaIdealYaw() < 10 ) + { + TaskComplete(); + } + } + else + { + TaskFail(FAIL_NO_PLAYER); + } + } + break; + + case TASK_FIND_COVER_FROM_BEST_SOUND: + { + switch( GetTaskInterrupt() ) + { + case 0: + { + if ( !FindCoverFromBestSound( &m_vInterruptSavePosition ) ) + TaskFail(FAIL_NO_COVER); + else + { + GetNavigator()->IgnoreStoppingPath(); + LockBestSound(); + TaskInterrupt(); + } + } + break; + + case 1: + { + AI_NavGoal_t goal(m_vInterruptSavePosition, ACT_RUN, AIN_HULL_TOLERANCE); + + CSound *pBestSound = GetBestSound(); + if ( pBestSound ) + goal.maxInitialSimplificationDist = pBestSound->Volume() * 0.5; + + if ( GetNavigator()->SetGoal( goal ) ) + { + m_flMoveWaitFinished = gpGlobals->curtime + pTask->flTaskData; + } + } + break; + } + } + break; + + case TASK_FACE_HINTNODE: + case TASK_FACE_LASTPOSITION: + case TASK_FACE_SAVEPOSITION: + case TASK_FACE_AWAY_FROM_SAVEPOSITION: + case TASK_FACE_TARGET: + case TASK_FACE_IDEAL: + case TASK_FACE_SCRIPT: + case TASK_FACE_PATH: + { + // If the yaw is locked, this function will not act correctly + Assert( GetMotor()->IsYawLocked() == false ); + + GetMotor()->UpdateYaw(); + + if ( FacingIdeal() ) + { + TaskComplete(); + } + break; + } + + case TASK_FACE_REASONABLE: + { + // If the yaw is locked, this function will not act correctly + Assert( GetMotor()->IsYawLocked() == false ); + + GetMotor()->UpdateYaw(); + + if ( FacingIdeal() ) + { + TaskComplete(); + } + break; + } + case TASK_WAIT_PVS: + { + if ( ShouldAlwaysThink() || + UTIL_FindClientInPVS(edict()) || + ( GetState() == NPC_STATE_COMBAT && GetEnemy() && gpGlobals->curtime - GetEnemies()->LastTimeSeen( GetEnemy() ) < 15 ) ) + { + TaskComplete(); + } + break; + } + case TASK_WAIT_INDEFINITE: + { + // don't do anything. + break; + } + case TASK_WAIT: + case TASK_WAIT_RANDOM: + { + if ( IsWaitFinished() ) + { + TaskComplete(); + } + break; + } + case TASK_WAIT_FACE_ENEMY: + case TASK_WAIT_FACE_ENEMY_RANDOM: + { + Vector vecEnemyLKP = GetEnemyLKP(); + if (!FInAimCone( vecEnemyLKP )) + { + GetMotor()->SetIdealYawToTargetAndUpdate( vecEnemyLKP , AI_KEEP_YAW_SPEED ); + } + + if ( IsWaitFinished() ) + { + TaskComplete(); + } + break; + } + case TASK_WAIT_UNTIL_NO_DANGER_SOUND: + if( !HasCondition( COND_HEAR_DANGER ) ) + { + TaskComplete(); + } + break; + + case TASK_MOVE_TO_TARGET_RANGE: + case TASK_MOVE_TO_GOAL_RANGE: + { + // Identical tasks, except that target_range uses m_hTargetEnt, + // and Goal range uses the nav goal + CBaseEntity *pTarget = NULL; + if ( pTask->iTask == TASK_MOVE_TO_GOAL_RANGE ) + { + pTarget = GetNavigator()->GetGoalTarget(); + } + if ( !pTarget ) + { + pTarget = m_hTargetEnt.Get(); + } + + float distance; + + if ( pTarget == NULL ) + { + TaskFail(FAIL_NO_TARGET); + } + else if (GetNavigator()->GetGoalType() == GOALTYPE_NONE) + { + TaskComplete(); + GetNavigator()->ClearGoal(); // Clear residual state + } + else + { + bool bForceRun = false; + + // Check Z first, and only check 2d if we're within that + Vector vecGoalPos = GetNavigator()->GetGoalPos(); + distance = fabs(vecGoalPos.z - GetLocalOrigin().z); + if ( distance < pTask->flTaskData ) + { + distance = ( vecGoalPos - GetLocalOrigin() ).Length2D(); + } + else + { + // If the target is significantly higher or lower than me, I must run. + bForceRun = true; + } + + // If we're jumping, wait until we're finished to update our goal position. + if ( GetNavigator()->GetNavType() != NAV_JUMP ) + { + // Re-evaluate when you think your finished, or the target has moved too far + if ( (distance < pTask->flTaskData) || (vecGoalPos - pTarget->GetAbsOrigin()).Length() > pTask->flTaskData * 0.5 ) + { + distance = ( pTarget->GetAbsOrigin() - GetLocalOrigin() ).Length2D(); + if ( !GetNavigator()->UpdateGoalPos( pTarget->GetAbsOrigin() ) ) + { + TaskFail( FAIL_NO_ROUTE ); + break; + } + } + } + + // Set the appropriate activity based on an overlapping range + // overlap the range to prevent oscillation + // BUGBUG: this is checking linear distance (ie. through walls) and not path distance or even visibility + if ( distance < pTask->flTaskData ) + { + TaskComplete(); +#ifndef HL2_DLL + // HL2 uses TASK_STOP_MOVING + GetNavigator()->StopMoving(); // Stop moving +#endif + } + else + { + // Pick the right movement activity. + Activity followActivity; + + if( bForceRun ) + { + followActivity = ACT_RUN; + } + else + { + followActivity = ( distance < 190 && m_NPCState != NPC_STATE_COMBAT ) ? ACT_WALK : 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( pTarget ); + } + } + break; + } + case TASK_GET_PATH_TO_ENEMY_LOS: + case TASK_GET_FLANK_RADIUS_PATH_TO_ENEMY_LOS: + case TASK_GET_FLANK_ARC_PATH_TO_ENEMY_LOS: + case TASK_GET_PATH_TO_ENEMY_LKP_LOS: + { + if ( GetEnemy() == NULL ) + { + TaskFail(FAIL_NO_ENEMY); + return; + } + if ( GetTaskInterrupt() > 0 ) + { + ClearTaskInterrupt(); + + Vector vecEnemy = ( pTask->iTask == TASK_GET_PATH_TO_ENEMY_LOS ) ? GetEnemy()->GetAbsOrigin() : GetEnemyLKP(); + AI_NavGoal_t goal( m_vInterruptSavePosition, ACT_RUN, AIN_HULL_TOLERANCE ); + + GetNavigator()->SetGoal( goal, AIN_CLEAR_TARGET ); + GetNavigator()->SetArrivalDirection( vecEnemy - goal.dest ); + } + else + TaskInterrupt(); + } + break; + + case TASK_GET_PATH_AWAY_FROM_BEST_SOUND: + { + ChainRunTask( TASK_MOVE_AWAY_PATH, pTask->flTaskData ); + if ( GetNavigator()->IsGoalActive() ) + { + Vector vecDest = GetNavigator()->GetGoalPos(); + float flDist = ( GetAbsOrigin() - vecDest ).Length(); + + if( flDist < 10.0 * 12.0 ) + { + TaskFail("Path away from best sound too short!\n"); + } + } + break; + } + + case TASK_MOVE_AWAY_PATH: + { + QAngle ang = GetLocalAngles(); + ang.y = GetMotor()->GetIdealYaw() + 180; + Vector move; + + switch ( GetTaskInterrupt() ) + { + case 0: + { + if( IsPlayerAlly() ) + { + // Look for a move away hint node. + CAI_Hint *pHint; + CHintCriteria hintCriteria; + + hintCriteria.AddHintType( HINT_PLAYER_ALLY_MOVE_AWAY_DEST ); + hintCriteria.SetFlag( bits_HINT_NODE_NEAREST ); + hintCriteria.AddIncludePosition( GetAbsOrigin(), (20.0f * 12.0f) ); // 20 feet max + hintCriteria.AddExcludePosition( GetAbsOrigin(), 28.0f ); // don't plant on an hint that you start on + + pHint = CAI_HintManager::FindHint( this, hintCriteria ); + + if( pHint ) + { + CBasePlayer *pPlayer = AI_GetSinglePlayer(); + Vector vecGoal = pHint->GetAbsOrigin(); + + if( vecGoal.DistToSqr(GetAbsOrigin()) < vecGoal.DistToSqr(pPlayer->GetAbsOrigin()) ) + { + if( GetNavigator()->SetGoal(vecGoal) ) + { + pHint->DisableForSeconds( 0.1f ); // Force others to find their own. + TaskComplete(); + break; + } + } + } + } + +#ifdef HL2_EPISODIC + // See if we're moving away from a vehicle + CSound *pBestSound = GetBestSound( SOUND_MOVE_AWAY ); + if ( pBestSound && pBestSound->m_hOwner && pBestSound->m_hOwner->GetServerVehicle() ) + { + // Move away from the vehicle's center, regardless of our facing + move = ( GetAbsOrigin() - pBestSound->m_hOwner->WorldSpaceCenter() ); + VectorNormalize( move ); + } + else + { + // Use the first angles + AngleVectors( ang, &move ); + } +#else + AngleVectors( ang, &move ); +#endif //HL2_EPISODIC + if ( GetNavigator()->SetVectorGoal( move, (float)pTask->flTaskData, MIN(36,pTask->flTaskData), true ) && IsValidMoveAwayDest( GetNavigator()->GetGoalPos() )) + { + TaskComplete(); + } + else + { + ang.y = GetMotor()->GetIdealYaw() + 91; + AngleVectors( ang, &move ); + + if ( GetNavigator()->SetVectorGoal( move, (float)pTask->flTaskData, MIN(24,pTask->flTaskData), true ) && IsValidMoveAwayDest( GetNavigator()->GetGoalPos() ) ) + { + TaskComplete(); + } + else + { + TaskInterrupt(); + } + } + } + break; + + case 1: + { + ang.y = GetMotor()->GetIdealYaw() + 271; + AngleVectors( ang, &move ); + + if ( GetNavigator()->SetVectorGoal( move, (float)pTask->flTaskData, MIN(24,pTask->flTaskData), true ) && IsValidMoveAwayDest( GetNavigator()->GetGoalPos() ) ) + { + TaskComplete(); + } + else + { + ang.y = GetMotor()->GetIdealYaw() + 180; + while (ang.y < 0) + ang.y += 360; + while (ang.y >= 360) + ang.y -= 360; + if ( ang.y < 45 || ang.y >= 315 ) + ang.y = 0; + else if ( ang.y < 135 ) + ang.y = 90; + else if ( ang.y < 225 ) + ang.y = 180; + else + ang.y = 270; + + AngleVectors( ang, &move ); + + if ( GetNavigator()->SetVectorGoal( move, (float)pTask->flTaskData, MIN(6,pTask->flTaskData), false ) && IsValidMoveAwayDest( GetNavigator()->GetGoalPos() ) ) + { + TaskComplete(); + } + else + { + TaskInterrupt(); + } + } + } + break; + + case 2: + { + ClearTaskInterrupt(); + Vector coverPos; + + if ( GetTacticalServices()->FindCoverPos( GetLocalOrigin(), EyePosition(), 0, CoverRadius(), &coverPos ) && IsValidMoveAwayDest( GetNavigator()->GetGoalPos() ) ) + { + GetNavigator()->SetGoal( AI_NavGoal_t( coverPos, ACT_RUN ) ); + m_flMoveWaitFinished = gpGlobals->curtime + 2; + } + else + { + // no coverwhatsoever. + TaskFail(FAIL_NO_ROUTE); + } + } + break; + + } + } + break; + + case TASK_WEAPON_RUN_PATH: + case TASK_ITEM_RUN_PATH: + { + CBaseEntity *pTarget = m_hTargetEnt; + if ( pTarget ) + { + if ( pTarget->GetOwnerEntity() ) + { + TaskFail(FAIL_WEAPON_OWNED); + } + else if (GetNavigator()->GetGoalType() == GOALTYPE_NONE) + { + TaskComplete(); + } + } + else + { + TaskFail(FAIL_ITEM_NO_FIND); + } + } + break; + + case TASK_WAIT_FOR_MOVEMENT_STEP: + case TASK_WAIT_FOR_MOVEMENT: + { + bool fTimeExpired = ( pTask->flTaskData != 0 && pTask->flTaskData < gpGlobals->curtime - GetTimeTaskStarted() ); + + if (fTimeExpired || GetNavigator()->GetGoalType() == GOALTYPE_NONE) + { + TaskComplete(); + GetNavigator()->StopMoving(); // Stop moving + } + else if (!GetNavigator()->IsGoalActive()) + { + SetIdealActivity( GetStoppedActivity() ); + } + else + { + // Check validity of goal type + ValidateNavGoal(); + } + break; + } + + case TASK_DIE: + RunDieTask(); + break; + + case TASK_WAIT_FOR_SPEAK_FINISH: + Assert( GetExpresser() ); + if ( GetExpresser() ) + { + // Are we waiting for our speech to end? Or for the mutex to be free? + if ( pTask->flTaskData ) + { + // Waiting for our speech to end + if ( GetExpresser()->CanSpeakAfterMyself() ) + { + TaskComplete(); + } + } + else + { + // Waiting for the speech & the delay afterwards + if ( !GetExpresser()->IsSpeaking() ) + { + TaskComplete(); + } + } + } + break; + + case TASK_SCRIPT_RUN_TO_TARGET: + case TASK_SCRIPT_WALK_TO_TARGET: + case TASK_SCRIPT_CUSTOM_MOVE_TO_TARGET: + StartScriptMoveToTargetTask( pTask->iTask ); + break; + + case TASK_RANGE_ATTACK1: + case TASK_RANGE_ATTACK2: + case TASK_MELEE_ATTACK1: + case TASK_MELEE_ATTACK2: + case TASK_SPECIAL_ATTACK1: + case TASK_SPECIAL_ATTACK2: + case TASK_RELOAD: + RunAttackTask( pTask->iTask ); + break; + + case TASK_SMALL_FLINCH: + case TASK_BIG_FLINCH: + { + if ( IsActivityFinished() ) + { + TaskComplete(); + } + } + break; + + case TASK_WAIT_FOR_SCRIPT: + { + // + // Waiting to play a script. If the script is ready, start playing the sequence. + // + if ( m_hCine && m_hCine->IsTimeToStart() ) + { + TaskComplete(); + m_hCine->OnBeginSequence(); + + // If we have an entry, we have to play it first + if ( m_hCine->m_iszEntry != NULL_STRING ) + { + m_hCine->StartSequence( (CAI_BaseNPC *)this, m_hCine->m_iszEntry, true ); + } + else + { + m_hCine->StartSequence( (CAI_BaseNPC *)this, m_hCine->m_iszPlay, true ); + } + + // StartSequence() can call CineCleanup(). If that happened, just exit schedule + if ( !m_hCine ) + { + ClearSchedule( "Waiting for script, but lost script!" ); + } + + m_flPlaybackRate = 1.0; + //DevMsg( 2, "Script %s has begun for %s\n", STRING( m_hCine->m_iszPlay ), GetClassname() ); + } + else if (!m_hCine) + { + DevMsg( "Cine died!\n"); + TaskComplete(); + } + else if ( IsRunningDynamicInteraction() ) + { + // If we've lost our partner, abort + if ( !m_hInteractionPartner ) + { + CineCleanup(); + } + } + break; + } + case TASK_PLAY_SCRIPT: + { + // + // Playing a scripted sequence. + // + AutoMovement( ); + + if ( IsSequenceFinished() ) + { + // Check to see if we are done with the action sequence. + if ( m_hCine->FinishedActionSequence( this ) ) + { + // dvs: This is done in FixScriptNPCSchedule -- doing it here is too early because we still + // need to play our post-action idle sequence, which might also require FL_FLY. + // + // drop to ground if this guy is only marked "fly" because of the auto movement + /*if ( !(m_hCine->m_savedFlags & FL_FLY) ) + { + if ( ( GetFlags() & FL_FLY ) && !m_hCine->m_bIgnoreGravity ) + { + RemoveFlag( FL_FLY ); + } + }*/ + + if (m_hCine) + { + m_hCine->SequenceDone( this ); + } + + TaskComplete(); + } + else if ( m_hCine && m_hCine->m_bForceSynch ) + { + m_hCine->SynchronizeSequence( this ); + } + } + break; + } + + case TASK_PLAY_SCRIPT_POST_IDLE: + { + if ( !m_hCine ) + { + DevMsg( "Scripted sequence destroyed while in use\n" ); + TaskFail( FAIL_SCHEDULE_NOT_FOUND ); + break; + } + + // + // Playing a scripted post idle sequence. Quit early if another sequence has grabbed the NPC. + // + if ( IsSequenceFinished() || ( m_hCine->m_hNextCine != NULL ) ) + { + m_hCine->PostIdleDone( this ); + } + break; + } + + case TASK_ENABLE_SCRIPT: + { + if ( !m_hCine ) + { + DevMsg( "Scripted sequence destroyed while in use\n" ); + TaskFail( FAIL_SCHEDULE_NOT_FOUND ); + break; + } + + if (!m_hCine->IsWaitingForBegin()) + { + m_hCine->DelayStart( false ); + TaskComplete(); + } + break; + } + + + case TASK_PLAY_SCENE: + { + if (!IsInLockedScene()) + { + ClearSchedule( "Playing a scene, but not in a scene!" ); + } + if (GetNavigator()->GetGoalType() != GOALTYPE_NONE) + { + TaskComplete(); + } + break; + } + + case TASK_RUN_PATH_FOR_UNITS: + case TASK_WALK_PATH_FOR_UNITS: + { + float distance; + + distance = (m_vecLastPosition - GetLocalOrigin()).Length2D(); + + // Walk path until far enough away + if ( distance > pTask->flTaskData || + GetNavigator()->GetGoalType() == GOALTYPE_NONE ) + { + TaskComplete(); + } + break; + } + + case TASK_RUN_PATH_FLEE: + { + Vector vecDiff; + vecDiff = GetLocalOrigin() - GetNavigator()->GetGoalPos(); + + if( vecDiff.Length() <= pTask->flTaskData ) + { + TaskComplete(); + } + break; + } + + case TASK_WALK_PATH_WITHIN_DIST: + case TASK_RUN_PATH_WITHIN_DIST: + { + Vector vecDiff; + + vecDiff = GetLocalOrigin() - GetNavigator()->GetGoalPos(); + + if( vecDiff.Length() <= pTask->flTaskData ) + { + TaskComplete(); + } + break; + } + + case TASK_WALK_PATH_TIMED: + case TASK_RUN_PATH_TIMED: + { + if ( IsWaitFinished() || + GetNavigator()->GetGoalType() == GOALTYPE_NONE ) + { + TaskComplete(); + } + } + break; + + case TASK_WEAPON_PICKUP: + { + if ( IsActivityFinished() ) + { + CBaseCombatWeapon *pWeapon = dynamic_cast<CBaseCombatWeapon *>( (CBaseEntity *)m_hTargetEnt); + CBaseCombatCharacter *pOwner = pWeapon->GetOwner(); + if ( !pOwner ) + { + TaskComplete(); + } + else + { + TaskFail(FAIL_WEAPON_OWNED); + } + } + break; + } + break; + + case TASK_ITEM_PICKUP: + { + if ( IsActivityFinished() ) + { + TaskComplete(); + } + break; + } + break; + + case TASK_FALL_TO_GROUND: + if ( GetFlags() & FL_ONGROUND ) + { + TaskComplete(); + } + else if( GetFlags() & FL_FLY ) + { + // We're never going to fall if we're FL_FLY. + RemoveFlag( FL_FLY ); + } + else + { + if( IsWaitFinished() ) + { + // After 4 seconds of trying to fall to ground, Assume that we're in a bad case where the NPC + // isn't actually falling, and make an attempt to slam the ground entity to whatever's under the NPC. + Vector maxs = WorldAlignMaxs() - Vector( .1, .1, .2 ); + Vector mins = WorldAlignMins() + Vector( .1, .1, 0 ); + Vector vecStart = GetAbsOrigin() + Vector( 0, 0, .1 ); + Vector vecDown = GetAbsOrigin(); + vecDown.z -= 0.2; + + trace_t trace; + m_pMoveProbe->TraceHull( vecStart, vecDown, mins, maxs, MASK_NPCSOLID, &trace ); + + if( trace.m_pEnt ) + { + // Found something! + SetGroundEntity( trace.m_pEnt ); + TaskComplete(); + } + else + { + // Try again in a few seconds. + SetWait(4); + } + } + } + break; + + case TASK_WANDER: + break; + + case TASK_FREEZE: + break; + + default: + { + DevMsg( "No RunTask entry for %s\n", TaskName( pTask->iTask ) ); + TaskComplete(); + } + break; + } +} + +void CAI_BaseNPC::RunTaskOverlay() +{ + if ( IsCurTaskContinuousMove() ) + { + m_MoveAndShootOverlay.RunShootWhileMove(); + } +} + +void CAI_BaseNPC::EndTaskOverlay() +{ + m_MoveAndShootOverlay.EndShootWhileMove(); +} + +//========================================================= +// SetTurnActivity - measures the difference between the way +// the NPC is facing and determines whether or not to +// select one of the 180 turn animations. +//========================================================= +void CAI_BaseNPC::SetTurnActivity ( void ) +{ + if ( IsCrouching() ) + { + SetIdealActivity( ACT_IDLE ); // failure case + return; + } + + float flYD; + flYD = GetMotor()->DeltaIdealYaw(); + + // FIXME: unknown case, update yaw should catch these + /* + if (GetMotor()->AddTurnGesture( flYD )) + { + SetIdealActivity( ACT_IDLE ); + Remember( bits_MEMORY_TURNING ); + return; + } + */ + + if( flYD <= -80 && flYD >= -100 && SelectWeightedSequence( ACT_90_RIGHT ) != ACTIVITY_NOT_AVAILABLE ) + { + // 90 degree right. + Remember( bits_MEMORY_TURNING ); + SetIdealActivity( ACT_90_RIGHT ); + return; + } + if( flYD >= 80 && flYD <= 100 && SelectWeightedSequence( ACT_90_LEFT ) != ACTIVITY_NOT_AVAILABLE ) + { + // 90 degree left. + Remember( bits_MEMORY_TURNING ); + SetIdealActivity( ACT_90_LEFT ); + return; + } + if( fabs( flYD ) >= 160 && SelectWeightedSequence ( ACT_180_LEFT ) != ACTIVITY_NOT_AVAILABLE ) + { + Remember( bits_MEMORY_TURNING ); + SetIdealActivity( ACT_180_LEFT ); + return; + } + + if ( flYD <= -45 && SelectWeightedSequence ( ACT_TURN_RIGHT ) != ACTIVITY_NOT_AVAILABLE ) + {// big right turn + SetIdealActivity( ACT_TURN_RIGHT ); + return; + } + if ( flYD >= 45 && SelectWeightedSequence ( ACT_TURN_LEFT ) != ACTIVITY_NOT_AVAILABLE ) + {// big left turn + SetIdealActivity( ACT_TURN_LEFT ); + return; + } + + SetIdealActivity( ACT_IDLE ); // failure case + +} + + +//----------------------------------------------------------------------------- +// Purpose: For a specific delta, add a turn gesture and set the yaw speed +// Input : yaw delta +//----------------------------------------------------------------------------- + + +bool CAI_BaseNPC::UpdateTurnGesture( void ) +{ + float flYD = GetMotor()->DeltaIdealYaw(); + return GetMotor()->AddTurnGesture( flYD ); +} + + +//----------------------------------------------------------------------------- +// Purpose: For non-looping animations that may be replayed sequentially (like attacks) +// Set the activity to ACT_RESET if this is a replay, otherwise just set ideal activity +// Input : newIdealActivity - desired ideal activity +//----------------------------------------------------------------------------- +void CAI_BaseNPC::ResetIdealActivity( Activity newIdealActivity ) +{ + if ( m_Activity == newIdealActivity ) + { + m_Activity = ACT_RESET; + } + + SetIdealActivity( newIdealActivity ); +} + + +void CAI_BaseNPC::TranslateNavGoal( CBaseEntity *pEnemy, Vector &chasePosition ) +{ + if ( GetNavType() == NAV_FLY ) + { + // UNDONE: Cache these per enemy instead? + Vector offset = pEnemy->EyePosition() - pEnemy->GetAbsOrigin(); + chasePosition += offset; + } +} + + +//----------------------------------------------------------------------------- +// Purpose: Returns the custom movement activity for the script that this NPC +// is running. +// Output : Returns the activity, or ACT_INVALID is the sequence is unknown. +//----------------------------------------------------------------------------- +Activity CAI_BaseNPC::GetScriptCustomMoveActivity( void ) +{ + Activity eActivity = ACT_WALK; + + if ( ( m_hCine != NULL ) && ( m_hCine->m_iszCustomMove != NULL_STRING ) ) + { + // We have a valid script. Look up the custom movement activity. + eActivity = ( Activity )LookupActivity( STRING( m_hCine->m_iszCustomMove ) ); + if ( eActivity == ACT_INVALID ) + { + // Not an activity, at least make sure it's a valid sequence. + if ( LookupSequence( STRING( m_hCine->m_iszCustomMove ) ) != ACT_INVALID ) + { + eActivity = ACT_SCRIPT_CUSTOM_MOVE; + } + else + { + eActivity = ACT_WALK; + } + } + } + else if ( m_iszSceneCustomMoveSeq != NULL_STRING ) + { + eActivity = ACT_SCRIPT_CUSTOM_MOVE; + } + + return eActivity; +} + + +//----------------------------------------------------------------------------- +// Purpose: +// Output : int +//----------------------------------------------------------------------------- +int CAI_BaseNPC::GetScriptCustomMoveSequence( void ) +{ + int iSequence = ACTIVITY_NOT_AVAILABLE; + + // If we have a scripted sequence entity, use it's custom move + if ( m_hCine != NULL ) + { + iSequence = LookupSequence( STRING( m_hCine->m_iszCustomMove ) ); + if ( iSequence == ACTIVITY_NOT_AVAILABLE ) + { + DevMsg( "SCRIPT_CUSTOM_MOVE: %s has no sequence:%s\n", GetClassname(), STRING(m_hCine->m_iszCustomMove) ); + } + } + else if ( m_iszSceneCustomMoveSeq != NULL_STRING ) + { + // Otherwise, use the .vcd custom move + iSequence = LookupSequence( STRING( m_iszSceneCustomMoveSeq ) ); + if ( iSequence == ACTIVITY_NOT_AVAILABLE ) + { + Warning( "SCRIPT_CUSTOM_MOVE: %s failed scripted custom move. Has no sequence called: %s\n", GetClassname(), STRING(m_iszSceneCustomMoveSeq) ); + } + } + + // Failed? Use walk. + if ( iSequence == ACTIVITY_NOT_AVAILABLE ) + { + iSequence = SelectWeightedSequence( ACT_WALK ); + } + + return iSequence; +} + +//========================================================= +// GetTask - returns a pointer to the current +// scheduled task. NULL if there's a problem. +//========================================================= +const Task_t *CAI_BaseNPC::GetTask( void ) +{ + int iScheduleIndex = GetScheduleCurTaskIndex(); + if ( !GetCurSchedule() || iScheduleIndex < 0 || iScheduleIndex >= GetCurSchedule()->NumTasks() ) + // iScheduleIndex is not within valid range for the NPC's current schedule. + return NULL; + + return &GetCurSchedule()->GetTaskList()[ iScheduleIndex ]; +} + + +//----------------------------------------------------------------------------- +bool CAI_BaseNPC::IsInterruptable() +{ + if ( GetState() == NPC_STATE_SCRIPT ) + { + if ( m_hCine ) + { + if (!m_hCine->CanInterrupt() ) + return false; + + // are the in an script FL_FLY state? + if ((GetFlags() & FL_FLY ) && !(m_hCine->m_savedFlags & FL_FLY)) + { + return false; + } + } + } + + return IsAlive(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +int CAI_BaseNPC::SelectInteractionSchedule( void ) +{ + SetTarget( m_hForcedInteractionPartner ); + + // If we have an interaction, we're the initiator. Move to our interaction point. + if ( m_iInteractionPlaying != NPCINT_NONE ) + return SCHED_INTERACTION_MOVE_TO_PARTNER; + + // Otherwise, turn towards our partner and wait for him to reach us. + //m_iInteractionState = NPCINT_MOVING_TO_MARK; + return SCHED_INTERACTION_WAIT_FOR_PARTNER; +} + +//----------------------------------------------------------------------------- +// Idle schedule selection +//----------------------------------------------------------------------------- +int CAI_BaseNPC::SelectIdleSchedule() +{ + if ( m_hForcedInteractionPartner ) + return SelectInteractionSchedule(); + + int nSched = SelectFlinchSchedule(); + if ( nSched != SCHED_NONE ) + return nSched; + + if ( HasCondition ( COND_HEAR_DANGER ) || + HasCondition ( COND_HEAR_COMBAT ) || + HasCondition ( COND_HEAR_WORLD ) || + HasCondition ( COND_HEAR_BULLET_IMPACT ) || + HasCondition ( COND_HEAR_PLAYER ) ) + { + return SCHED_ALERT_FACE_BESTSOUND; + } + + // no valid route! + if (GetNavigator()->GetGoalType() == GOALTYPE_NONE) + return SCHED_IDLE_STAND; + + // valid route. Get moving + return SCHED_IDLE_WALK; +} + + +//----------------------------------------------------------------------------- +// Alert schedule selection +//----------------------------------------------------------------------------- +int CAI_BaseNPC::SelectAlertSchedule() +{ + if ( m_hForcedInteractionPartner ) + return SelectInteractionSchedule(); + + int nSched = SelectFlinchSchedule(); + if ( nSched != SCHED_NONE ) + return nSched; + + // Scan around for new enemies + if ( HasCondition( COND_ENEMY_DEAD ) && SelectWeightedSequence( ACT_VICTORY_DANCE ) != ACTIVITY_NOT_AVAILABLE ) + return SCHED_ALERT_SCAN; + + if( IsPlayerAlly() && HasCondition(COND_HEAR_COMBAT) ) + { + return SCHED_ALERT_REACT_TO_COMBAT_SOUND; + } + + if ( HasCondition ( COND_HEAR_DANGER ) || + HasCondition ( COND_HEAR_PLAYER ) || + HasCondition ( COND_HEAR_WORLD ) || + HasCondition ( COND_HEAR_BULLET_IMPACT ) || + HasCondition ( COND_HEAR_COMBAT ) ) + { + return SCHED_ALERT_FACE_BESTSOUND; + } + + if ( gpGlobals->curtime - GetEnemies()->LastTimeSeen( AI_UNKNOWN_ENEMY ) < TIME_CARE_ABOUT_DAMAGE ) + return SCHED_ALERT_FACE; + + return SCHED_ALERT_STAND; +} + + +//----------------------------------------------------------------------------- +// Combat schedule selection +//----------------------------------------------------------------------------- +int CAI_BaseNPC::SelectCombatSchedule() +{ + if ( m_hForcedInteractionPartner ) + return SelectInteractionSchedule(); + + int nSched = SelectFlinchSchedule(); + if ( nSched != SCHED_NONE ) + return nSched; + + if ( HasCondition(COND_NEW_ENEMY) && gpGlobals->curtime - GetEnemies()->FirstTimeSeen(GetEnemy()) < 2.0 ) + { + return SCHED_WAKE_ANGRY; + } + + if ( HasCondition( COND_ENEMY_DEAD ) ) + { + // clear the current (dead) enemy and try to find another. + SetEnemy( NULL ); + + if ( ChooseEnemy() ) + { + ClearCondition( COND_ENEMY_DEAD ); + return SelectSchedule(); + } + + SetState( NPC_STATE_ALERT ); + return SelectSchedule(); + } + + // If I'm scared of this enemy run away + if ( IRelationType( GetEnemy() ) == D_FR ) + { + if (HasCondition( COND_SEE_ENEMY ) || + HasCondition( COND_LIGHT_DAMAGE )|| + HasCondition( COND_HEAVY_DAMAGE )) + { + FearSound(); + //ClearCommandGoal(); + return SCHED_RUN_FROM_ENEMY; + } + + // If I've seen the enemy recently, cower. Ignore the time for unforgettable enemies. + AI_EnemyInfo_t *pMemory = GetEnemies()->Find( GetEnemy() ); + if ( (pMemory && pMemory->bUnforgettable) || (GetEnemyLastTimeSeen() > (gpGlobals->curtime - 5.0)) ) + { + // If we're facing him, just look ready. Otherwise, face him. + if ( FInAimCone( GetEnemy()->EyePosition() ) ) + return SCHED_COMBAT_STAND; + + return SCHED_FEAR_FACE; + } + } + + // Check if need to reload + if ( HasCondition( COND_LOW_PRIMARY_AMMO ) || HasCondition( COND_NO_PRIMARY_AMMO ) ) + { + return SCHED_HIDE_AND_RELOAD; + } + + // Can we see the enemy? + if ( !HasCondition(COND_SEE_ENEMY) ) + { + // enemy is unseen, but not occluded! + // turn to face enemy + if ( !HasCondition(COND_ENEMY_OCCLUDED) ) + return SCHED_COMBAT_FACE; + + // chase! + if ( GetActiveWeapon() || (CapabilitiesGet() & (bits_CAP_INNATE_RANGE_ATTACK1|bits_CAP_INNATE_RANGE_ATTACK2))) + return SCHED_ESTABLISH_LINE_OF_FIRE; + else if ( (CapabilitiesGet() & (bits_CAP_INNATE_MELEE_ATTACK1|bits_CAP_INNATE_MELEE_ATTACK2))) + return SCHED_CHASE_ENEMY; + else + return SCHED_TAKE_COVER_FROM_ENEMY; + } + + if ( HasCondition(COND_TOO_CLOSE_TO_ATTACK) ) + return SCHED_BACK_AWAY_FROM_ENEMY; + + if ( HasCondition( COND_WEAPON_PLAYER_IN_SPREAD ) || + HasCondition( COND_WEAPON_BLOCKED_BY_FRIEND ) || + HasCondition( COND_WEAPON_SIGHT_OCCLUDED ) ) + { + return SCHED_ESTABLISH_LINE_OF_FIRE; + } + + if ( GetShotRegulator()->IsInRestInterval() ) + { + if ( HasCondition(COND_CAN_RANGE_ATTACK1) ) + return SCHED_COMBAT_FACE; + } + + // we can see the enemy + if ( HasCondition(COND_CAN_RANGE_ATTACK1) ) + { + if ( !UseAttackSquadSlots() || OccupyStrategySlotRange( SQUAD_SLOT_ATTACK1, SQUAD_SLOT_ATTACK2 ) ) + return SCHED_RANGE_ATTACK1; + return SCHED_COMBAT_FACE; + } + + if ( HasCondition(COND_CAN_RANGE_ATTACK2) ) + return SCHED_RANGE_ATTACK2; + + if ( HasCondition(COND_CAN_MELEE_ATTACK1) ) + return SCHED_MELEE_ATTACK1; + + if ( HasCondition(COND_CAN_MELEE_ATTACK2) ) + return SCHED_MELEE_ATTACK2; + + if ( HasCondition(COND_NOT_FACING_ATTACK) ) + return SCHED_COMBAT_FACE; + + if ( !HasCondition(COND_CAN_RANGE_ATTACK1) && !HasCondition(COND_CAN_MELEE_ATTACK1) ) + { + // if we can see enemy but can't use either attack type, we must need to get closer to enemy + if ( GetActiveWeapon() ) + return SCHED_MOVE_TO_WEAPON_RANGE; + + // If we have an innate attack and we're too far (or occluded) then get line of sight + if ( HasCondition( COND_TOO_FAR_TO_ATTACK ) && ( CapabilitiesGet() & (bits_CAP_INNATE_RANGE_ATTACK1|bits_CAP_INNATE_RANGE_ATTACK2)) ) + return SCHED_MOVE_TO_WEAPON_RANGE; + + // if we can see enemy but can't use either attack type, we must need to get closer to enemy + if ( CapabilitiesGet() & (bits_CAP_INNATE_MELEE_ATTACK1|bits_CAP_INNATE_MELEE_ATTACK2) ) + return SCHED_CHASE_ENEMY; + else + return SCHED_TAKE_COVER_FROM_ENEMY; + } + + DevWarning( 2, "No suitable combat schedule!\n" ); + return SCHED_FAIL; +} + + +//----------------------------------------------------------------------------- +// Dead schedule selection +//----------------------------------------------------------------------------- +int CAI_BaseNPC::SelectDeadSchedule() +{ + if ( BecomeRagdollOnClient( vec3_origin ) ) + { + CleanupOnDeath(); + return SCHED_DIE_RAGDOLL; + } + + // Adrian - Alread dead (by animation event maybe?) + // Is it safe to set it to SCHED_NONE? + if ( m_lifeState == LIFE_DEAD ) + return SCHED_NONE; + + CleanupOnDeath(); + return SCHED_DIE; +} + + +//----------------------------------------------------------------------------- +// Script schedule selection +//----------------------------------------------------------------------------- +int CAI_BaseNPC::SelectScriptSchedule() +{ + Assert( m_hCine != NULL ); + if ( m_hCine ) + return SCHED_AISCRIPT; + + DevWarning( 2, "Script failed for %s\n", GetClassname() ); + CineCleanup(); + return SCHED_IDLE_STAND; +} + +//----------------------------------------------------------------------------- +// Purpose: Select a gesture to play in response to damage we've taken +// Output : int +//----------------------------------------------------------------------------- +void CAI_BaseNPC::PlayFlinchGesture() +{ + if ( !CanFlinch() ) + return; + + Activity iFlinchActivity = ACT_INVALID; + + float flNextFlinch = random->RandomFloat( 0.5f, 1.0f ); + + // If I haven't flinched for a while, play the big flinch gesture + if ( !HasMemory(bits_MEMORY_FLINCHED) ) + { + iFlinchActivity = GetFlinchActivity( true, true ); + + if ( HaveSequenceForActivity( iFlinchActivity ) ) + { + RestartGesture( iFlinchActivity ); + } + + Remember(bits_MEMORY_FLINCHED); + + } + else + { + iFlinchActivity = GetFlinchActivity( false, true ); + if ( HaveSequenceForActivity( iFlinchActivity ) ) + { + RestartGesture( iFlinchActivity ); + } + } + + if ( iFlinchActivity != ACT_INVALID ) + { + //Get the duration of the flinch and delay the next one by that (plus a bit more) + int iSequence = GetLayerSequence( FindGestureLayer( iFlinchActivity ) ); + + if ( iSequence != ACT_INVALID ) + { + flNextFlinch += SequenceDuration( iSequence ); + } + + m_flNextFlinchTime = gpGlobals->curtime + flNextFlinch; + } +} + +//----------------------------------------------------------------------------- +// Purpose: See if we should flinch in response to damage we've taken +// Output : int +//----------------------------------------------------------------------------- +int CAI_BaseNPC::SelectFlinchSchedule() +{ + if ( !HasCondition(COND_HEAVY_DAMAGE) ) + return SCHED_NONE; + + // If we've flinched recently, don't do it again. A gesture flinch will be played instead. + if ( HasMemory(bits_MEMORY_FLINCHED) ) + return SCHED_NONE; + + if ( !CanFlinch() ) + return SCHED_NONE; + + // Robin: This was in the original HL1 flinch code. Do we still want it? + //if ( fabs( GetMotor()->DeltaIdealYaw() ) < (1.0 - m_flFieldOfView) * 60 ) // roughly in the correct direction + // return SCHED_TAKE_COVER_FROM_ORIGIN; + + // Heavy damage. Break out of my current schedule and flinch. + Activity iFlinchActivity = GetFlinchActivity( true, false ); + if ( HaveSequenceForActivity( iFlinchActivity ) ) + return SCHED_BIG_FLINCH; + + /* + // Not used anymore, because gesture flinches are played instead for heavy damage + // taken shortly after we've already flinched full. + // + iFlinchActivity = GetFlinchActivity( false, false ); + if ( HaveSequenceForActivity( iFlinchActivity ) ) + return SCHED_SMALL_FLINCH; + */ + + return SCHED_NONE; +} + +//----------------------------------------------------------------------------- +// Purpose: Decides which type of schedule best suits the NPC's current +// state and conditions. Then calls NPC's member function to get a pointer +// to a schedule of the proper type. +//----------------------------------------------------------------------------- +int CAI_BaseNPC::SelectSchedule( void ) +{ + if ( HasCondition( COND_FLOATING_OFF_GROUND ) ) + { + SetGravity( 1.0 ); + SetGroundEntity( NULL ); + return SCHED_FALL_TO_GROUND; + } + + switch( m_NPCState ) + { + case NPC_STATE_NONE: + DevWarning( 2, "NPC_STATE IS NONE!\n" ); + break; + + case NPC_STATE_PRONE: + return SCHED_IDLE_STAND; + + case NPC_STATE_IDLE: + AssertMsgOnce( GetEnemy() == NULL, "NPC has enemy but is not in combat state?" ); + return SelectIdleSchedule(); + + case NPC_STATE_ALERT: + AssertMsgOnce( GetEnemy() == NULL, "NPC has enemy but is not in combat state?" ); + return SelectAlertSchedule(); + + case NPC_STATE_COMBAT: + return SelectCombatSchedule(); + + case NPC_STATE_DEAD: + return SelectDeadSchedule(); + + case NPC_STATE_SCRIPT: + return SelectScriptSchedule(); + + default: + DevWarning( 2, "Invalid State for SelectSchedule!\n" ); + break; + } + + return SCHED_FAIL; +} + + +//----------------------------------------------------------------------------- + +int CAI_BaseNPC::SelectFailSchedule( int failedSchedule, int failedTask, AI_TaskFailureCode_t taskFailCode ) +{ + return ( m_failSchedule != SCHED_NONE ) ? m_failSchedule : SCHED_FAIL; +} |