//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:		Base NPC character with AI
//
//=============================================================================//

#ifndef AI_BASENPC_H
#define AI_BASENPC_H

#ifdef _WIN32
#pragma once
#endif

#include "activitylist.h"
#include "ai_basenpc.h"
#include "ai_component.h"
#include "ai_condition.h"
#include "ai_debug.h"
#include "ai_default.h"
#include "ai_hull.h"
#include "ai_moveshoot.h"
#include "ai_movetypes.h"
#include "ai_namespaces.h"
#include "ai_navgoaltype.h"  //GoalType_t enum
#include "ai_navigator.h"
#include "ai_navtype.h"
#include "ai_npcstate.h"
#include "ai_schedule.h"
#include "ai_task.h"
#include "ai_utils.h"
#include "basecombatcharacter.h"
#include "bitstring.h"
#include "entityoutput.h"
#include "eventlist.h"
#include "simtimer.h"
#include "soundent.h"
#include "tier1/functors.h"
#include "utlvector.h"

#define PLAYER_SQUADNAME "player_squad"

class CAI_Schedule;
class CAI_Network;
class CAI_Route;
class CAI_Hint;
class CAI_Node;
class CAI_Navigator;
class CAI_Pathfinder;
class CAI_Senses;
class CAI_Enemies;
class CAI_Squad;
class CAI_Expresser;
class CAI_BehaviorBase;
class CAI_GoalEntity;
class CAI_Motor;
class CAI_MoveProbe;
class CAI_LocalNavigator;
class CAI_TacticalServices;
class CVarBitVec;
class CAI_ScriptedSequence;
class CSceneEntity;
class CBaseGrenade;
class CBaseDoor;
class CBasePropDoor;
struct AI_Waypoint_t;
class AI_Response;
class CBaseFilter;

typedef CBitVec<MAX_CONDITIONS> CAI_ScheduleBits;

// Used to control optimizations mostly dealing with pathfinding for NPCs
extern ConVar ai_strong_optimizations;

extern bool AIStrongOpt(void);

// AI_MONITOR_FOR_OSCILLATION defaults to OFF. If you build with this ON, you
// can flag NPC's and monitor them to detect oscillations in their schedule
// (circular logic and conditions bugs) DO NOT SHIP WITH THIS ON!
#undef AI_MONITOR_FOR_OSCILLATION

//=============================================================================
//
// Constants & enumerations
//
//=============================================================================
#define TURRET_CLOSE_RANGE 200
#define TURRET_MEDIUM_RANGE 500

#define COMMAND_GOAL_TOLERANCE 48  // 48 inches.
#define TIME_CARE_ABOUT_DAMAGE 3.0

#define ITEM_PICKUP_TOLERANCE 48.0f

// Max's of the box used to search for a weapon to pick up. 45x45x~8 ft.
#define WEAPON_SEARCH_DELTA Vector(540, 540, 100)

enum Interruptability_t {
    GENERAL_INTERRUPTABILITY,
    DAMAGEORDEATH_INTERRUPTABILITY,
    DEATH_INTERRUPTABILITY
};

//-------------------------------------
// Memory
//-------------------------------------

#define MEMORY_CLEAR 0
#define bits_MEMORY_PROVOKED (1 << 0)  // right now only used for houndeyes.
#define bits_MEMORY_INCOVER (1 << 1)   // npc knows it is in a covered position.
#define bits_MEMORY_SUSPICIOUS \
    (1 << 2)  // Ally is suspicious of the player, and will move to provoked
              // more easily
#define bits_MEMORY_TASK_EXPENSIVE \
    (1 << 3)  // NPC has completed a task which is considered costly, so don't
              // do another task this frame
//#define	bits_MEMORY_				( 1 << 4 )
#define bits_MEMORY_PATH_FAILED (1 << 5)  // Failed to find a path
#define bits_MEMORY_FLINCHED (1 << 6)     // Has already flinched
//#define bits_MEMORY_ 					( 1 << 7 )
#define bits_MEMORY_TOURGUIDE (1 << 8)  // I have been acting as a tourguide.
//#define bits_MEMORY_					( 1 << 9 )//
#define bits_MEMORY_LOCKED_HINT (1 << 10)  //
//#define bits_MEMORY_					( 1 << 12 )

#define bits_MEMORY_TURNING (1 << 13)  // Turning, don't interrupt me.
#define bits_MEMORY_TURNHACK (1 << 14)

#define bits_MEMORY_HAD_ENEMY (1 << 15)   // Had an enemy
#define bits_MEMORY_HAD_PLAYER (1 << 16)  // Had player
#define bits_MEMORY_HAD_LOS (1 << 17)     // Had LOS to enemy

#define bits_MEMORY_MOVED_FROM_SPAWN (1 << 18)  // Has moved since spawning.

#define bits_MEMORY_CUSTOM4 (1 << 28)  // NPC-specific memory
#define bits_MEMORY_CUSTOM3 (1 << 29)  // NPC-specific memory
#define bits_MEMORY_CUSTOM2 (1 << 30)  // NPC-specific memory
#define bits_MEMORY_CUSTOM1 (1 << 31)  // NPC-specific memory

//-------------------------------------
// Spawn flags
//-------------------------------------
#define SF_NPC_WAIT_TILL_SEEN \
    (1 << 0)  // spawnflag that makes npcs wait until player can see them before
              // attacking.
#define SF_NPC_GAG (1 << 1)              // no idle noises from this npc
#define SF_NPC_FALL_TO_GROUND (1 << 2)   // used my NPC_Maker
#define SF_NPC_DROP_HEALTHKIT (1 << 3)   // Drop a healthkit upon death
#define SF_NPC_START_EFFICIENT (1 << 4)  // Set into efficiency mode from spawn
//										( 1 << 5
//) 										( 1 << 6  )
#define SF_NPC_WAIT_FOR_SCRIPT \
    (1 << 7)  // spawnflag that makes npcs wait to check for attacking until the
              // script is done or they've been attacked
#define SF_NPC_LONG_RANGE \
    (1 << 8)  // makes npcs look far and relaxes weapon range limit
#define SF_NPC_FADE_CORPSE (1 << 9)   // Fade out corpse after death
#define SF_NPC_ALWAYSTHINK (1 << 10)  // Simulate even when player isn't in PVS.
#define SF_NPC_TEMPLATE \
    (1 << 11)  // This NPC will be used as a template by an npc_maker -- do not
               // spawn.
#define SF_NPC_ALTCOLLISION (1 << 12)
#define SF_NPC_NO_WEAPON_DROP \
    (1 << 13)  // This NPC will not actually drop a weapon that can be picked up
#define SF_NPC_NO_PLAYER_PUSHAWAY (1 << 14)
//										( 1 << 15
//)
// !! Flags above ( 1 << 15 )	 are reserved for NPC sub-classes

//-------------------------------------
//
// Return codes from CanPlaySequence.
//
//-------------------------------------

enum CanPlaySequence_t {
    CANNOT_PLAY = 0,    // Can't play for any number of reasons.
    CAN_PLAY_NOW,       // Can play the script immediately.
    CAN_PLAY_ENQUEUED,  // Can play the script after I finish playing my current
                        // script.
};

//-------------------------------------
// Weapon holstering
//-------------------------------------
enum DesiredWeaponState_t {
    DESIREDWEAPONSTATE_IGNORE = 0,
    DESIREDWEAPONSTATE_HOLSTERED,
    DESIREDWEAPONSTATE_HOLSTERED_DESTROYED,  // Put the weapon away, then
                                             // destroy it.
    DESIREDWEAPONSTATE_UNHOLSTERED,
    DESIREDWEAPONSTATE_CHANGING,
    DESIREDWEAPONSTATE_CHANGING_DESTROY,  // Destroy the weapon when this change
                                          // is complete.
};

//-------------------------------------
//
// Efficiency modes
//
//-------------------------------------

enum AI_Efficiency_t {
    // Run at full tilt
    AIE_NORMAL,

    // Run decision process less often
    AIE_EFFICIENT,

    // Run decision process even less often, ignore other NPCs
    AIE_VERY_EFFICIENT,

    // Run decision process even less often, ignore other NPCs
    AIE_SUPER_EFFICIENT,

    // Don't run at all
    AIE_DORMANT,
};

enum AI_MoveEfficiency_t {
    AIME_NORMAL,
    AIME_EFFICIENT,
};

//-------------------------------------
//
// Sleep state
//
//-------------------------------------

enum AI_SleepState_t {
    AISS_AWAKE,
    AISS_WAITING_FOR_THREAT,
    AISS_WAITING_FOR_PVS,
    AISS_WAITING_FOR_INPUT,
    AISS_AUTO_PVS,
    AISS_AUTO_PVS_AFTER_PVS,  // Same as AUTO_PVS, except doesn't activate
                              // until/unless the NPC is IN the player's PVS.
};

#define AI_SLEEP_FLAGS_NONE 0x00000000
#define AI_SLEEP_FLAG_AUTO_PVS 0x00000001
#define AI_SLEEP_FLAG_AUTO_PVS_AFTER_PVS 0x00000002

//-------------------------------------
//
// Debug bits
//
//-------------------------------------

enum DebugBaseNPCBits_e {
    bits_debugDisableAI = 0x00000001,  // disable AI
    bits_debugStepAI = 0x00000002,     // step AI

};

//-------------------------------------
//
// Base Sentence index for behaviors
//
//-------------------------------------
enum SentenceIndex_t {
    SENTENCE_BASE_BEHAVIOR_INDEX = 1000,
};

#ifdef AI_MONITOR_FOR_OSCILLATION
struct AIScheduleChoice_t {
    float m_flTimeSelected;
    CAI_Schedule *m_pScheduleSelected;
};
#endif  // AI_MONITOR_FOR_OSCILLATION

#define MARK_TASK_EXPENSIVE()                             \
    if (GetOuter()) {                                     \
        GetOuter()->Remember(bits_MEMORY_TASK_EXPENSIVE); \
    }

//=============================================================================
//
// Types used by CAI_BaseNPC
//
//=============================================================================

struct AIScheduleState_t {
    int iCurTask;
    TaskStatus_e fTaskStatus;
    float timeStarted;
    float timeCurTaskStarted;
    AI_TaskFailureCode_t taskFailureCode;
    int iTaskInterrupt;
    bool bTaskRanAutomovement;
    bool bTaskUpdatedYaw;
    bool bScheduleWasInterrupted;

    DECLARE_SIMPLE_DATADESC();
};

// -----------------------------------------
//	An entity that this NPC can't reach
// -----------------------------------------

struct UnreachableEnt_t {
    EHANDLE hUnreachableEnt;  // Entity that's unreachable
    float fExpireTime;        // Time to forget this information
    Vector vLocationWhenUnreachable;

    DECLARE_SIMPLE_DATADESC();
};

//=============================================================================
// SCRIPTED NPC INTERACTIONS
//=============================================================================
// -----------------------------------------
//	Scripted NPC interaction flags
// -----------------------------------------
#define SCNPC_FLAG_TEST_OTHER_ANGLES (1 << 1)
#define SCNPC_FLAG_TEST_OTHER_VELOCITY (1 << 2)
#define SCNPC_FLAG_LOOP_IN_ACTION (1 << 3)
#define SCNPC_FLAG_NEEDS_WEAPON_ME (1 << 4)
#define SCNPC_FLAG_NEEDS_WEAPON_THEM (1 << 5)
#define SCNPC_FLAG_DONT_TELEPORT_AT_END_ME (1 << 6)
#define SCNPC_FLAG_DONT_TELEPORT_AT_END_THEM (1 << 7)

// -----------------------------------------
//	Scripted NPC interaction trigger methods
// -----------------------------------------
enum {
    SNPCINT_CODE = 0,
    SNPCINT_AUTOMATIC_IN_COMBAT = 1,
};

// -----------------------------------------
//	Scripted NPC interaction loop breaking trigger methods
// -----------------------------------------
#define SNPCINT_LOOPBREAK_ON_DAMAGE (1 << 1)
#define SNPCINT_LOOPBREAK_ON_FLASHLIGHT_ILLUM (1 << 2)

// -----------------------------------------
//	Scripted NPC interaction anim phases
// -----------------------------------------
enum {
    SNPCINT_ENTRY = 0,
    SNPCINT_SEQUENCE,
    SNPCINT_EXIT,

    SNPCINT_NUM_PHASES
};

struct ScriptedNPCInteraction_Phases_t {
    string_t iszSequence;
    int iActivity;

    DECLARE_SIMPLE_DATADESC();
};

// Allowable delta from the desired dynamic scripted sequence point
#define DSS_MAX_DIST 6
#define DSS_MAX_ANGLE_DIFF 4

// Interaction Logic States
enum {
    NPCINT_NOT_RUNNING = 0,
    NPCINT_RUNNING_ACTIVE,   // I'm in an interaction that I initiated
    NPCINT_RUNNING_PARTNER,  // I'm in an interaction that was initiated by the
                             // other NPC
    NPCINT_MOVING_TO_MARK,   // I'm moving to a position to do an interaction
};

#define NPCINT_NONE -1

#define MAXTACLAT_IGNORE -1

// -----------------------------------------
//	A scripted interaction between NPCs
// -----------------------------------------
struct ScriptedNPCInteraction_t {
    ScriptedNPCInteraction_t() {
        iszInteractionName = NULL_STRING;
        iFlags = 0;
        iTriggerMethod = SNPCINT_CODE;
        iLoopBreakTriggerMethod = 0;
        vecRelativeOrigin = vec3_origin;
        bValidOnCurrentEnemy = false;
        flDelay = 5.0;
        flDistSqr = (DSS_MAX_DIST * DSS_MAX_DIST);
        flNextAttemptTime = 0;
        iszMyWeapon = NULL_STRING;
        iszTheirWeapon = NULL_STRING;

        for (int i = 0; i < SNPCINT_NUM_PHASES; i++) {
            sPhases[i].iszSequence = NULL_STRING;
            sPhases[i].iActivity = ACT_INVALID;
        }
    }

    // Fill out these when passing to AddScriptedNPCInteraction
    string_t iszInteractionName;
    int iFlags;
    int iTriggerMethod;
    int iLoopBreakTriggerMethod;
    Vector vecRelativeOrigin;  // (forward, right, up)
    QAngle angRelativeAngles;
    Vector vecRelativeVelocity;  // Desired relative velocity of the other NPC
    float flDelay;               // Delay before interaction can be used again
    float flDistSqr;  // Max distance sqr from the relative origin the NPC is
                      // allowed to be to trigger
    string_t iszMyWeapon;     // Classname of the weapon I'm holding, if any
    string_t iszTheirWeapon;  // Classname of the weapon my interaction partner
                              // is holding, if any
    ScriptedNPCInteraction_Phases_t sPhases[SNPCINT_NUM_PHASES];

    // These will be filled out for you in AddScriptedNPCInteraction
    VMatrix matDesiredLocalToWorld;  // Desired relative position / angles of
                                     // the other NPC
    bool bValidOnCurrentEnemy;

    float flNextAttemptTime;

    DECLARE_SIMPLE_DATADESC();
};

//=============================================================================
//
// Utility functions
//
//=============================================================================

Vector VecCheckToss(CBaseEntity *pEdict, Vector vecSpot1, Vector vecSpot2,
                    float flHeightMaxRatio, float flGravityAdj, bool bRandomize,
                    Vector *vecMins = NULL, Vector *vecMaxs = NULL);
Vector VecCheckToss(CBaseEntity *pEntity, ITraceFilter *pFilter,
                    Vector vecSpot1, Vector vecSpot2, float flHeightMaxRatio,
                    float flGravityAdj, bool bRandomize, Vector *vecMins = NULL,
                    Vector *vecMaxs = NULL);
Vector VecCheckThrow(CBaseEntity *pEdict, const Vector &vecSpot1,
                     Vector vecSpot2, float flSpeed, float flGravityAdj = 1.0f,
                     Vector *vecMins = NULL, Vector *vecMaxs = NULL);

extern Vector g_vecAttackDir;

bool FBoxVisible(CBaseEntity *pLooker, CBaseEntity *pTarget);
bool FBoxVisible(CBaseEntity *pLooker, CBaseEntity *pTarget,
                 Vector &vecTargetOrigin, float flSize = 0.0);

// FIXME: move to utils?
float DeltaV(float v0, float v1, float d);
float ChangeDistance(float flInterval, float flGoalDistance,
                     float flGoalVelocity, float flCurVelocity,
                     float flIdealVelocity, float flAccelRate,
                     float &flNewDistance, float &flNewVelocity);

//=============================================================================
//
// class CAI_Manager
//
// Central location for components of the AI to operate across all AIs without
// iterating over the global list of entities.
//
//=============================================================================

class CAI_Manager {
   public:
    CAI_Manager();

    CAI_BaseNPC **AccessAIs();
    int NumAIs();

    void AddAI(CAI_BaseNPC *pAI);
    void RemoveAI(CAI_BaseNPC *pAI);

    bool FindAI(CAI_BaseNPC *pAI) {
        return (m_AIs.Find(pAI) != m_AIs.InvalidIndex());
    }

   private:
    enum { MAX_AIS = 256 };

    typedef CUtlVector<CAI_BaseNPC *> CAIArray;

    CAIArray m_AIs;
};

//-------------------------------------

extern CAI_Manager g_AI_Manager;

//=============================================================================
//
//	class CAI_BaseNPC
//
//=============================================================================

class CAI_BaseNPC : public CBaseCombatCharacter, public CAI_DefMovementSink {
    DECLARE_CLASS(CAI_BaseNPC, CBaseCombatCharacter);

   public:
    //-----------------------------------------------------
    //
    // Initialization, cleanup, serialization, identity
    //

    CAI_BaseNPC();
    ~CAI_BaseNPC();

    //---------------------------------

    DECLARE_DATADESC();
    DECLARE_SERVERCLASS();

    virtual int Save(ISave &save);
    virtual int Restore(IRestore &restore);
    virtual void OnRestore();
    void SaveConditions(ISave &save, const CAI_ScheduleBits &conditions);
    void RestoreConditions(IRestore &restore, CAI_ScheduleBits *pConditions);

    bool ShouldSavePhysics() { return false; }
    virtual unsigned int PhysicsSolidMaskForEntity(void) const;

    virtual bool KeyValue(const char *szKeyName, const char *szValue);

    //---------------------------------

    virtual void PostConstructor(const char *szClassname);
    virtual void Activate(void);
    virtual void Precache(void);  // derived calls at start of Spawn()
    virtual bool CreateVPhysics();
    virtual void NPCInit(void);  // derived calls after Spawn()
    void NPCInitThink(void);
    virtual void PostNPCInit(){};  // called after NPC_InitThink
    virtual void StartNPC(void);
    virtual bool IsTemplate(void);

    virtual void CleanupOnDeath(CBaseEntity *pCulprit = NULL,
                                bool bFireDeathOutput = true);
    virtual void UpdateOnRemove(void);

    virtual int UpdateTransmitState();

    //---------------------------------
    // Component creation factories
    //

    // The master call, override if you introduce new component types. Call base
    // first
    virtual bool CreateComponents();

    // Components defined by the base AI class
    virtual CAI_Senses *CreateSenses();
    virtual CAI_MoveProbe *CreateMoveProbe();
    virtual CAI_Motor *CreateMotor();
    virtual CAI_LocalNavigator *CreateLocalNavigator();
    virtual CAI_Navigator *CreateNavigator();
    virtual CAI_Pathfinder *CreatePathfinder();
    virtual CAI_TacticalServices *CreateTacticalServices();

    //---------------------------------

    virtual bool IsNPC(void) const { return true; }

    //---------------------------------

    void TestPlayerPushing(CBaseEntity *pPlayer);
    void CascadePlayerPush(const Vector &push, const Vector &pushOrigin);
    void NotifyPushMove();

   public:
    //-----------------------------------------------------
    //
    // AI processing - thinking, schedule selection and task running
    //
    //-----------------------------------------------------
    void CallNPCThink(void);

    // Thinking, including core thinking, movement, animation
    virtual void NPCThink(void);

    // Core thinking (schedules & tasks)
    virtual void RunAI(void);  // core ai function!

    // Called to gather up all relevant conditons
    virtual void GatherConditions(void);

    // Called immediately prior to schedule processing
    virtual void PrescheduleThink(void);

    // Called immediately after schedule processing
    virtual void PostscheduleThink(void) { return; };

    // Notification that the current schedule, if any, is ending and a new one
    // is being selected
    virtual void OnScheduleChange(void);

    // Notification that a new schedule is about to run its first task
    virtual void OnStartSchedule(int scheduleType){};

    // This function implements a decision tree for the NPC.  It is responsible
    // for choosing the next behavior (schedule) based on the current conditions
    // and state.
    virtual int SelectSchedule(void);
    virtual int SelectFailSchedule(int failedSchedule, int failedTask,
                                   AI_TaskFailureCode_t taskFailCode);

    // After the schedule has been selected, it will be processed by this
    // function so child NPC classes can remap base schedules into
    // child-specific behaviors
    virtual int TranslateSchedule(int scheduleType);

    virtual void StartTask(const Task_t *pTask);
    virtual void RunTask(const Task_t *pTask);

    void ClearTransientConditions();

    virtual void HandleAnimEvent(animevent_t *pEvent);

    virtual bool IsInterruptable();
    virtual void OnStartScene(void) {
    }  // Called when an NPC begins a cine scene (useful for clean-up)
    virtual bool ShouldPlayerAvoid(void);
    virtual void SetPlayerAvoidState(void);
    virtual void PlayerPenetratingVPhysics(void);

    virtual bool ShouldAlwaysThink();
    void ForceGatherConditions() {
        m_bForceConditionsGather = true;
        SetEfficiency(AIE_NORMAL);
    }  // Force an NPC out of PVS to call GatherConditions on next think

    virtual float LineOfSightDist(const Vector &vecDir = vec3_invalid,
                                  float zEye = FLT_MAX);

    virtual void MakeTracer(const Vector &vecTracerSrc, const trace_t &tr,
                            int iTracerType);
    virtual const char *GetTracerType(void);
    virtual void DoImpactEffect(trace_t &tr, int nDamageType);

    enum {
        NEXT_SCHEDULE = LAST_SHARED_SCHEDULE,
        NEXT_TASK = LAST_SHARED_TASK,
        NEXT_CONDITION = LAST_SHARED_CONDITION,
    };

   protected:
    // Used by derived classes to chain a task to a task that might not be the
    // one they are currently handling:
    void ChainStartTask(int task, float taskData = 0) {
        Task_t tempTask = {task, taskData};
        StartTask((const Task_t *)&tempTask);
    }
    void ChainRunTask(int task, float taskData = 0) {
        Task_t tempTask = {task, taskData};
        RunTask((const Task_t *)&tempTask);
    }

    void StartTaskOverlay();
    void RunTaskOverlay();
    void EndTaskOverlay();

    virtual void PostRunStopMoving();

    bool CheckPVSCondition();

   private:
    bool CanThinkRebalance();
    void RebalanceThinks();

    bool PreNPCThink();
    void PostNPCThink();

    bool PreThink(void);
    void PerformSensing();
    void CheckOnGround(void);
    void MaintainSchedule(void);
    void RunAnimation(void);
    void PostRun(void);
    void PerformMovement();
    void PostMovement();

    virtual int StartTask(Task_t *pTask) {
        DevMsg("Called wrong StartTask()\n");
        StartTask((const Task_t *)pTask);
        return 0;
    }  // to ensure correct signature in derived classes
    virtual int RunTask(Task_t *pTask) {
        DevMsg("Called wrong RunTask()\n");
        RunTask((const Task_t *)pTask);
        return 0;
    }  // to ensure correct signature in derived classes

   public:
    //-----------------------------------------------------
    //
    // Schedules & tasks
    //
    //-----------------------------------------------------

    void SetSchedule(CAI_Schedule *pNewSchedule);
    bool SetSchedule(int localScheduleID);

    void SetDefaultFailSchedule(int failSchedule) {
        m_failSchedule = failSchedule;
    }

    void ClearSchedule(const char *szReason);

    CAI_Schedule *GetCurSchedule() { return m_pSchedule; }
    bool IsCurSchedule(int schedId, bool fIdeal = true);
    virtual CAI_Schedule *GetSchedule(int localScheduleID);
    virtual int GetLocalScheduleId(int globalScheduleID) {
        return AI_IdIsLocal(globalScheduleID)
                   ? globalScheduleID
                   : GetClassScheduleIdSpace()->ScheduleGlobalToLocal(
                         globalScheduleID);
    }
    virtual int GetGlobalScheduleId(int localScheduleID) {
        return AI_IdIsGlobal(localScheduleID)
                   ? localScheduleID
                   : GetClassScheduleIdSpace()->ScheduleLocalToGlobal(
                         localScheduleID);
    }

    float GetTimeScheduleStarted() const { return m_ScheduleState.timeStarted; }

    //---------------------------------

    const Task_t *GetTask(void);
    int TaskIsRunning(void);

    virtual void TaskFail(AI_TaskFailureCode_t);
    void TaskFail(const char *pszGeneralFailText) {
        TaskFail(MakeFailCode(pszGeneralFailText));
    }
    void TaskComplete(bool fIgnoreSetFailedCondition = false);

    void TaskInterrupt() { m_ScheduleState.iTaskInterrupt++; }
    void ClearTaskInterrupt() { m_ScheduleState.iTaskInterrupt = 0; }
    int GetTaskInterrupt() const { return m_ScheduleState.iTaskInterrupt; }

    void TaskMovementComplete(void);
    inline int TaskIsComplete(void) {
        return (GetTaskStatus() == TASKSTATUS_COMPLETE);
    }

    virtual const char *TaskName(int taskID);

    float GetTimeTaskStarted() const {
        return m_ScheduleState.timeCurTaskStarted;
    }
    virtual int GetLocalTaskId(int globalTaskId) {
        return GetClassScheduleIdSpace()->TaskGlobalToLocal(globalTaskId);
    }

    virtual const char *GetSchedulingErrorName() { return "CAI_BaseNPC"; }

   protected:
    static bool LoadSchedules(void);
    virtual bool LoadedSchedules(void);
    virtual void BuildScheduleTestBits(void);

    //---------------------------------

    // This is the main call to select/translate a schedule
    virtual CAI_Schedule *GetNewSchedule(void);
    virtual CAI_Schedule *GetFailSchedule(void);

    //---------------------------------

    virtual bool CanFlinch(void);
    virtual void CheckFlinches(void);
    virtual void PlayFlinchGesture(void);
    int SelectFlinchSchedule(void);

    virtual bool IsAllowedToDodge(void);

    bool IsInChoreo() const;

   private:
    // This function maps the type through TranslateSchedule() and then
    // retrieves the pointer to the actual CAI_Schedule from the database of
    // schedules available to this class.
    CAI_Schedule *GetScheduleOfType(int scheduleType);

    bool FHaveSchedule(void);
    bool FScheduleDone(void);
    CAI_Schedule *ScheduleInList(const char *pName, CAI_Schedule **pList,
                                 int listCount);

    int GetScheduleCurTaskIndex() const { return m_ScheduleState.iCurTask; }
    inline int IncScheduleCurTaskIndex();
    inline void ResetScheduleCurTaskIndex();
    void NextScheduledTask(void);
    bool IsScheduleValid(void);
    bool ShouldSelectIdealState(void);

    // Selecting the ideal state
    NPC_STATE SelectIdleIdealState();
    NPC_STATE SelectAlertIdealState();
    NPC_STATE SelectScriptIdealState();

    // Various schedule selections based on NPC_STATE
    int SelectIdleSchedule();
    int SelectAlertSchedule();
    int SelectCombatSchedule();
    virtual int SelectDeadSchedule();
    int SelectScriptSchedule();
    int SelectInteractionSchedule();

    void OnStartTask(void) { SetTaskStatus(TASKSTATUS_RUN_MOVE_AND_TASK); }
    void SetTaskStatus(TaskStatus_e status) {
        m_ScheduleState.fTaskStatus = status;
    }
    TaskStatus_e GetTaskStatus() const { return m_ScheduleState.fTaskStatus; }

    void DiscardScheduleState();

    //---------------------------------

    CAI_Schedule *m_pSchedule;
    int m_IdealSchedule;
    AIScheduleState_t m_ScheduleState;
    int m_failSchedule;  // Schedule type to choose if current schedule fails
    bool m_bDoPostRestoreRefindPath;

    bool m_bUsingStandardThinkTime;
    float m_flLastRealThinkTime;
    int m_iFrameBlocked;
    bool m_bInChoreo;

    static int gm_iNextThinkRebalanceTick;
    static float gm_flTimeLastSpawn;
    static int gm_nSpawnedThisFrame;

   protected:  // pose parameters
    int m_poseAim_Pitch;
    int m_poseAim_Yaw;
    int m_poseMove_Yaw;
    virtual void PopulatePoseParameters(void);

   public:
    inline bool HasPoseMoveYaw() { return (m_poseMove_Yaw >= 0); }

    // Return the stored pose parameter for "move_yaw"
    inline int LookupPoseMoveYaw() { return m_poseMove_Yaw; }

    //-----------------------------------------------------
    //
    // Hooks for CAI_Behaviors, *if* derived class supports them
    //
    //-----------------------------------------------------
    template <class BEHAVIOR_TYPE>
    bool GetBehavior(BEHAVIOR_TYPE **ppBehavior) {
        CAI_BehaviorBase **ppBehaviors = AccessBehaviors();

        *ppBehavior = NULL;
        for (int i = 0; i < NumBehaviors(); i++) {
            *ppBehavior = dynamic_cast<BEHAVIOR_TYPE *>(ppBehaviors[i]);
            if (*ppBehavior) return true;
        }
        return false;
    }

    virtual CAI_BehaviorBase *GetRunningBehavior() { return NULL; }

    virtual bool ShouldAcceptGoal(CAI_BehaviorBase *pBehavior,
                                  CAI_GoalEntity *pGoal) {
        return true;
    }
    virtual void OnClearGoal(CAI_BehaviorBase *pBehavior,
                             CAI_GoalEntity *pGoal) {}

    // Notification that the status behavior ability to select schedules has
    // changed. Return "true" to signal a schedule interrupt is desired
    virtual bool OnBehaviorChangeStatus(CAI_BehaviorBase *pBehavior,
                                        bool fCanFinishSchedule) {
        return false;
    }

   private:
    virtual CAI_BehaviorBase **AccessBehaviors() { return NULL; }
    virtual int NumBehaviors() { return 0; }

   public:
    //-----------------------------------------------------
    //
    // Conditions
    //
    //-----------------------------------------------------

    virtual const char *ConditionName(int conditionID);

    virtual void RemoveIgnoredConditions(void);
    void SetCondition(int iCondition /*, bool state = true*/);
    bool HasCondition(int iCondition);
    bool HasCondition(int iCondition, bool bUseIgnoreConditions);
    bool HasInterruptCondition(int iCondition);
    bool HasConditionsToInterruptSchedule(int nLocalScheduleID);

    void ClearCondition(int iCondition);
    void ClearConditions(int *pConditions, int nConditions);
    void SetIgnoreConditions(int *pConditions, int nConditions);
    void ClearIgnoreConditions(int *pConditions, int nConditions);
    bool ConditionInterruptsCurSchedule(int iCondition);
    bool ConditionInterruptsSchedule(int schedule, int iCondition);

    void SetCustomInterruptCondition(int nCondition);
    bool IsCustomInterruptConditionSet(int nCondition);
    void ClearCustomInterruptCondition(int nCondition);
    void ClearCustomInterruptConditions(void);

    bool ConditionsGathered() const { return m_bConditionsGathered; }
    const CAI_ScheduleBits &AccessConditionBits() const { return m_Conditions; }
    CAI_ScheduleBits &AccessConditionBits() { return m_Conditions; }

    bool DidChooseEnemy() const { return !m_bSkippedChooseEnemy; }

   private:
    CAI_ScheduleBits m_Conditions;
    CAI_ScheduleBits
        m_CustomInterruptConditions;  // Bit string assembled by the schedule
                                      // running, then modified by leaf classes
                                      // to suit their needs
    CAI_ScheduleBits m_ConditionsPreIgnore;
    CAI_ScheduleBits m_InverseIgnoreConditions;

    bool m_bForceConditionsGather;
    bool m_bConditionsGathered;
    bool m_bSkippedChooseEnemy;

   public:
    //-----------------------------------------------------
    //
    // NPC State
    //
    //-----------------------------------------------------
    inline void SetIdealState(NPC_STATE eIdealState);
    inline NPC_STATE GetIdealState();
    virtual NPC_STATE SelectIdealState(void);

    void SetState(NPC_STATE State);
    virtual bool ShouldGoToIdleState(void) { return (false); }
    virtual void OnStateChange(NPC_STATE OldState,
                               NPC_STATE NewState){/*Base class doesn't care*/};

    NPC_STATE GetState(void) { return m_NPCState; }

    AI_Efficiency_t GetEfficiency() const { return m_Efficiency; }
    void SetEfficiency(AI_Efficiency_t efficiency) {
        m_Efficiency = efficiency;
    }
    AI_MoveEfficiency_t GetMoveEfficiency() const { return m_MoveEfficiency; }
    void SetMoveEfficiency(AI_MoveEfficiency_t efficiency) {
        m_MoveEfficiency = efficiency;
    }
    virtual void UpdateEfficiency(bool bInPVS);
    void ForceDecisionThink() {
        m_flNextDecisionTime = 0;
        SetEfficiency(AIE_NORMAL);
    }

    bool IsFlaggedEfficient() const {
        return HasSpawnFlags(SF_NPC_START_EFFICIENT);
    }

    AI_SleepState_t GetSleepState() const { return m_SleepState; }
    void SetSleepState(AI_SleepState_t sleepState) {
        m_SleepState = sleepState;
    }
    void AddSleepFlags(int flags) { m_SleepFlags |= flags; }
    void RemoveSleepFlags(int flags) { m_SleepFlags &= ~flags; }
    bool HasSleepFlags(int flags) { return (m_SleepFlags & flags) == flags; }

    void UpdateSleepState(bool bInPVS);
    virtual void Wake(bool bFireOutput = true);
    void Sleep();
    bool WokeThisTick() const;

    //---------------------------------

    NPC_STATE m_NPCState;  // npc's current state
    float m_flLastStateChangeTime;

   private:
    NPC_STATE m_IdealNPCState;  // npc should change to this state
    AI_Efficiency_t m_Efficiency;
    AI_MoveEfficiency_t m_MoveEfficiency;
    float m_flNextDecisionTime;

    AI_SleepState_t m_SleepState;
    int m_SleepFlags;
    float m_flWakeRadius;
    bool m_bWakeSquad;
    int m_nWakeTick;

   public:
    //-----------------------------------------------------
    //
    //	Activities
    //
    //-----------------------------------------------------

    Activity TranslateActivity(Activity idealActivity,
                               Activity *pIdealWeaponActivity = NULL);
    Activity NPC_TranslateActivity(Activity eNewActivity);
    Activity GetActivity(void) { return m_Activity; }
    virtual void SetActivity(Activity NewActivity);
    Activity GetIdealActivity(void) { return m_IdealActivity; }
    void SetIdealActivity(Activity NewActivity);
    void ResetIdealActivity(Activity newIdealActivity);
    void SetSequenceByName(const char *szSequence);
    void SetSequenceById(int iSequence);
    Activity GetScriptCustomMoveActivity(void);
    int GetScriptCustomMoveSequence(void);
    Activity GetStoppedActivity(void);
    inline bool HaveSequenceForActivity(Activity activity);
    inline bool IsActivityStarted(void);
    virtual bool IsActivityFinished(void);
    virtual bool IsActivityMovementPhased(Activity activity);
    virtual void OnChangeActivity(Activity eNewActivity);
    void MaintainActivity(void);
    void ResetActivity(void) { m_Activity = ACT_RESET; }

    void SetActivityAndSequence(Activity NewActivity, int iSequence,
                                Activity translatedActivity,
                                Activity weaponActivity);

   private:
    void AdvanceToIdealActivity(void);
    void ResolveActivityToSequence(Activity NewActivity, int &iSequence,
                                   Activity &translatedActivity,
                                   Activity &weaponActivity);

    Activity m_Activity;            // Current animation state
    Activity m_translatedActivity;  // Current actual translated animation

    Activity m_IdealActivity;  // Desired animation state
    int m_nIdealSequence;      // Desired animation sequence
    Activity
        m_IdealTranslatedActivity;  // Desired actual translated animation state
    Activity m_IdealWeaponActivity;  // Desired weapon animation state

    CNetworkVar(int, m_iDeathPose);
    CNetworkVar(int, m_iDeathFrame);

   public:
    //-----------------------------------------------------
    //
    // Senses
    //
    //-----------------------------------------------------

    CAI_Senses *GetSenses() { return m_pSenses; }
    const CAI_Senses *GetSenses() const { return m_pSenses; }

    void SetDistLook(float flDistLook);

    virtual bool QueryHearSound(CSound *pSound);
    virtual bool QuerySeeEntity(CBaseEntity *pEntity,
                                bool bOnlyHateOrFearIfNPC = false);

    virtual void OnLooked(int iDistance);
    virtual void OnListened();

    virtual void OnSeeEntity(CBaseEntity *pEntity) {}

    // If true, AI will try to see this entity regardless of distance.
    virtual bool ShouldNotDistanceCull() { return false; }

    virtual int GetSoundInterests(void);
    virtual int GetSoundPriority(CSound *pSound);

    CSound *GetLoudestSoundOfType(int iType);
    virtual CSound *GetBestSound(int validTypes = ALL_SOUNDS);
    virtual CSound *GetBestScent(void);
    virtual float HearingSensitivity(void) { return 1.0; }
    virtual bool ShouldIgnoreSound(CSound *) { return false; }
    bool SoundIsVisible(CSound *pSound);

   protected:
    virtual void ClearSenseConditions(void);

   private:
    void LockBestSound();
    void UnlockBestSound();

    CAI_Senses *m_pSenses;
    CSound *m_pLockedBestSound;

   public:
    //-----------------------------------------------------
    //
    // Enemy and target
    //
    //-----------------------------------------------------

    Vector GetSmoothedVelocity(void);

    CBaseEntity *GetEnemy() { return m_hEnemy.Get(); }
    CBaseEntity *GetEnemy() const { return m_hEnemy.Get(); }
    float GetTimeEnemyAcquired() { return m_flTimeEnemyAcquired; }
    void SetEnemy(CBaseEntity *pEnemy, bool bSetCondNewEnemy = true);

    const Vector &GetEnemyLKP() const;
    float GetEnemyLastTimeSeen() const;
    void MarkEnemyAsEluded();
    void ClearEnemyMemory();
    bool EnemyHasEludedMe() const;

    virtual CBaseEntity *BestEnemy();  // returns best enemy in memory list
    virtual bool IsValidEnemy(CBaseEntity *pEnemy);
    virtual bool CanBeAnEnemyOf(CBaseEntity *pEnemy);

    void ForceChooseNewEnemy() { m_EnemiesSerialNumber = -1; }

    bool ChooseEnemy();
    virtual bool ShouldChooseNewEnemy();
    virtual void GatherEnemyConditions(CBaseEntity *pEnemy);
    virtual float EnemyDistTolerance() {
        return 0;
    }  // Enemy distances within this tolerance of each other are considered
       // equivalent.

    float EnemyDistance(CBaseEntity *pEnemy);
    CBaseCombatCharacter *GetEnemyCombatCharacterPointer();
    void SetEnemyOccluder(CBaseEntity *pBlocker);
    CBaseEntity *GetEnemyOccluder(void);

    virtual void StartTargetHandling(CBaseEntity *pTargetEnt);

    //---------------------------------

    CBaseEntity *GetTarget() { return m_hTargetEnt.Get(); }
    void SetTarget(CBaseEntity *pTarget);
    void CheckTarget(CBaseEntity *pTarget);
    float GetAcceptableTimeSeenEnemy(void) {
        return m_flAcceptableTimeSeenEnemy;
    }
    virtual CAI_BaseNPC *CreateCustomTarget(const Vector &vecOrigin,
                                            float duration = -1);

    void SetDeathPose(const int &iDeathPose) { m_iDeathPose = iDeathPose; }
    void SetDeathPoseFrame(const int &iDeathPoseFrame) {
        m_iDeathFrame = iDeathPoseFrame;
    }

    void SelectDeathPose(const CTakeDamageInfo &info);
    virtual bool ShouldPickADeathPose(void) { return true; }

    virtual bool AllowedToIgnite(void) { return false; }

   protected:
    virtual float GetGoalRepathTolerance(CBaseEntity *pGoalEnt, GoalType_t type,
                                         const Vector &curGoal,
                                         const Vector &curTargetPos);

   private:
    void *CheckEnemy(CBaseEntity *pEnemy) {
        return NULL;
    }  // OBSOLETE, replaced by GatherEnemyConditions(), left here to make
       // derived code not compile

    // Updates the goal position in case of GOALTYPE_ENEMY
    void UpdateEnemyPos();

    // Updates the goal position in case of GOALTYPE_TARGETENT
    void UpdateTargetPos();

    //---------------------------------

    EHANDLE m_hEnemy;             // the entity that the npc is fighting.
    float m_flTimeEnemyAcquired;  // The time at which the entity the NPC is
                                  // fighting became the NPC's enemy.
    EHANDLE m_hTargetEnt;         // the entity that the npc is trying to reach

    CRandStopwatch m_GiveUpOnDeadEnemyTimer;
    CSimpleSimTimer m_FailChooseEnemyTimer;
    int m_EnemiesSerialNumber;

    float m_flAcceptableTimeSeenEnemy;

    CSimpleSimTimer m_UpdateEnemyPosTimer;
    static CSimpleSimTimer m_AnyUpdateEnemyPosTimer;

   public:
    //-----------------------------------------------------
    //
    // Commander mode stuff.
    //
    //-----------------------------------------------------
    virtual bool IsCommandable() { return false; }
    virtual bool IsPlayerAlly(CBasePlayer *pPlayer = NULL);
    virtual bool IsMedic() { return false; }
    virtual bool IsCommandMoving() { return false; }
    virtual bool ShouldAutoSummon() { return false; }
    virtual void SetCommandGoal(const Vector &vecGoal);
    virtual void ClearCommandGoal();
    virtual void OnTargetOrder() {}
    virtual void OnMoveOrder() {}
    virtual bool IsValidCommandTarget(CBaseEntity *pTarget) { return false; }
    const Vector &GetCommandGoal() const { return m_vecCommandGoal; }
    virtual void OnMoveToCommandGoalFailed() {}
    string_t GetPlayerSquadName() const {
        Assert(gm_iszPlayerSquad != NULL_STRING);
        return gm_iszPlayerSquad;
    }
    bool IsInPlayerSquad() const;
    virtual CAI_BaseNPC *GetSquadCommandRepresentative() { return NULL; }

    virtual bool TargetOrder(CBaseEntity *pTarget, CAI_BaseNPC **Allies,
                             int numAllies) {
        OnTargetOrder();
        return true;
    }
    virtual void MoveOrder(const Vector &vecDest, CAI_BaseNPC **Allies,
                           int numAllies) {
        SetCommandGoal(vecDest);
        SetCondition(COND_RECEIVED_ORDERS);
        OnMoveOrder();
    }

    // Return true if you're willing to be idly talked to by other friends.
    virtual bool CanBeUsedAsAFriend(void);

   private:
    Vector m_vecCommandGoal;
    static string_t gm_iszPlayerSquad;

   public:
    CAI_MoveMonitor m_CommandMoveMonitor;

    //-----------------------------------------------------
    // Dynamic scripted NPC interactions
    //-----------------------------------------------------
   public:
    float GetInteractionYaw(void) const { return m_flInteractionYaw; }

   protected:
    void ParseScriptedNPCInteractions(void);
    void AddScriptedNPCInteraction(ScriptedNPCInteraction_t *pInteraction);
    const char *GetScriptedNPCInteractionSequence(
        ScriptedNPCInteraction_t *pInteraction, int iPhase);
    void StartRunningInteraction(CAI_BaseNPC *pOtherNPC, bool bActive);
    void StartScriptedNPCInteraction(CAI_BaseNPC *pOtherNPC,
                                     ScriptedNPCInteraction_t *pInteraction,
                                     Vector vecOtherOrigin,
                                     QAngle angOtherAngles);
    void CheckForScriptedNPCInteractions(void);
    void CalculateValidEnemyInteractions(void);
    void CheckForcedNPCInteractions(void);
    bool InteractionCouldStart(CAI_BaseNPC *pOtherNPC,
                               ScriptedNPCInteraction_t *pInteraction,
                               Vector &vecOrigin, QAngle &angAngles);
    virtual bool CanRunAScriptedNPCInteraction(bool bForced = false);
    bool IsRunningDynamicInteraction(void) {
        return (m_iInteractionState != NPCINT_NOT_RUNNING && (m_hCine != NULL));
    }
    bool IsActiveDynamicInteraction(void) {
        return (m_iInteractionState == NPCINT_RUNNING_ACTIVE &&
                (m_hCine != NULL));
    }
    ScriptedNPCInteraction_t *GetRunningDynamicInteraction(void) {
        return &(m_ScriptedInteractions[m_iInteractionPlaying]);
    }
    void SetInteractionCantDie(bool bCantDie) {
        m_bCannotDieDuringInteraction = bCantDie;
    }
    bool HasInteractionCantDie(void);

    void InputForceInteractionWithNPC(inputdata_t &inputdata);
    void StartForcedInteraction(CAI_BaseNPC *pNPC, int iInteraction);
    void CleanupForcedInteraction(void);
    void CalculateForcedInteractionPosition(void);
    CAI_BaseNPC *GetInteractionPartner(void);

   private:
    // Forced interactions
    CHandle<CAI_BaseNPC> m_hForcedInteractionPartner;
    Vector m_vecForcedWorldPosition;
    float m_flForcedInteractionTimeout;  // Abort the interaction if it hasn't
                                         // started by this time.

    CHandle<CAI_BaseNPC> m_hInteractionPartner;
    EHANDLE m_hLastInteractionTestTarget;
    bool m_bCannotDieDuringInteraction;
    int m_iInteractionState;
    int m_iInteractionPlaying;
    CUtlVector<ScriptedNPCInteraction_t> m_ScriptedInteractions;

    float m_flInteractionYaw;

   public:
    //-----------------------------------------------------
    //
    //  Sounds
    //
    //-----------------------------------------------------
    virtual CanPlaySequence_t CanPlaySequence(bool fDisregardState,
                                              int interruptLevel);

    virtual bool CanPlaySentence(bool fDisregardState) { return IsAlive(); }
    virtual int PlaySentence(const char *pszSentence, float delay, float volume,
                             soundlevel_t soundlevel,
                             CBaseEntity *pListener = NULL);
    virtual int PlayScriptedSentence(const char *pszSentence, float delay,
                                     float volume, soundlevel_t soundlevel,
                                     bool bConcurrent, CBaseEntity *pListener);

    virtual bool FOkToMakeSound(int soundPriority = 0);
    virtual void JustMadeSound(int soundPriority = 0,
                               float flSoundLength = 0.0f);

    virtual void DeathSound(const CTakeDamageInfo &info) { return; };
    virtual void AlertSound(void) { return; };
    virtual void IdleSound(void) { return; };
    virtual void PainSound(const CTakeDamageInfo &info) { return; };
    virtual void FearSound(void) { return; };
    virtual void LostEnemySound(void) { return; };
    virtual void FoundEnemySound(void) { return; };
    virtual void BarnacleDeathSound(void) {
        CTakeDamageInfo info;
        PainSound(info);
    }

    virtual void SpeakSentence(int sentenceType) { return; };
    virtual bool ShouldPlayIdleSound(void);

    virtual void MakeAIFootstepSound(float volume, float duration = 0.5f);

    //---------------------------------

    virtual CAI_Expresser *GetExpresser() { return NULL; }
    const CAI_Expresser *GetExpresser() const {
        return const_cast<CAI_BaseNPC *>(this)->GetExpresser();
    }

    //---------------------------------
    // NPC Event Response System
    virtual bool CanRespondToEvent(const char *ResponseConcept) {
        return false;
    }
    virtual bool RespondedTo(const char *ResponseConcept, bool bForce,
                             bool bCancelScene) {
        return false;
    }

    virtual void PlayerHasIlluminatedNPC(CBasePlayer *pPlayer, float flDot);

    virtual void ModifyOrAppendCriteria(AI_CriteriaSet &set);

   protected:
    float SoundWaitTime() const { return m_flSoundWaitTime; }

   public:
    //-----------------------------------------------------
    //
    // Capabilities report (from CBaseCombatCharacter)
    //
    //-----------------------------------------------------
    virtual int CapabilitiesGet(void) const;

    // local capabilities access
    int CapabilitiesAdd(int capabilities);
    int CapabilitiesRemove(int capabilities);
    void CapabilitiesClear(void);

   private:
    int m_afCapability;  // tells us what a npc can/can't do.

   public:
    //-----------------------------------------------------
    //
    // Pathfinding, navigation & movement
    //
    //-----------------------------------------------------

    CAI_Navigator *GetNavigator() { return m_pNavigator; }
    const CAI_Navigator *GetNavigator() const { return m_pNavigator; }

    CAI_LocalNavigator *GetLocalNavigator() { return m_pLocalNavigator; }
    const CAI_LocalNavigator *GetLocalNavigator() const {
        return m_pLocalNavigator;
    }

    CAI_Pathfinder *GetPathfinder() { return m_pPathfinder; }
    const CAI_Pathfinder *GetPathfinder() const { return m_pPathfinder; }

    CAI_MoveProbe *GetMoveProbe() { return m_pMoveProbe; }
    const CAI_MoveProbe *GetMoveProbe() const { return m_pMoveProbe; }

    CAI_Motor *GetMotor() { return m_pMotor; }
    const CAI_Motor *GetMotor() const { return m_pMotor; }

    //---------------------------------

    static bool FindSpotForNPCInRadius(Vector *pResult, const Vector &vStartPos,
                                       CAI_BaseNPC *pNPC, float radius,
                                       bool bOutOfPlayerViewcone = false);

    //---------------------------------

    virtual bool IsNavigationUrgent();
    virtual bool ShouldFailNav(bool bMovementFailed);
    virtual bool ShouldBruteForceFailedNav() { return false; }

    // The current navigation (movement) mode (e.g. fly, swim, locomote, etc)
    Navigation_t GetNavType() const;
    void SetNavType(Navigation_t navType);

    CBaseEntity *GetNavTargetEntity(void);

    bool IsMoving(void);
    virtual float GetTimeToNavGoal();

    // NPCs can override this to tweak with how costly particular movements are
    virtual bool MovementCost(int moveType, const Vector &vecStart,
                              const Vector &vecEnd, float *pCost);

    // Turns a directional vector into a yaw value that points down that vector.
    float VecToYaw(const Vector &vecDir);

    //  Turning
    virtual float CalcIdealYaw(const Vector &vecTarget);
    virtual float MaxYawSpeed(void);  // Get max yaw speed
    bool FacingIdeal(void);
    void SetUpdatedYaw() { m_ScheduleState.bTaskUpdatedYaw = true; }

    //   Add multiple facing goals while moving/standing still.
    virtual void AddFacingTarget(CBaseEntity *pTarget, float flImportance,
                                 float flDuration, float flRamp = 0.0);
    virtual void AddFacingTarget(const Vector &vecPosition, float flImportance,
                                 float flDuration, float flRamp = 0.0);
    virtual void AddFacingTarget(CBaseEntity *pTarget,
                                 const Vector &vecPosition, float flImportance,
                                 float flDuration, float flRamp = 0.0);
    virtual float GetFacingDirection(Vector &vecDir);

    // ------------
    // Methods used by motor to query properties/preferences/move-related state
    // ------------
    virtual bool CanStandOn(CBaseEntity *pSurface) const;

    virtual bool IsJumpLegal(
        const Vector &startPos, const Vector &apex,
        const Vector &endPos) const;  // Override for specific creature types
    bool IsJumpLegal(const Vector &startPos, const Vector &apex,
                     const Vector &endPos, float maxUp, float maxDown,
                     float maxDist) const;
    bool ShouldMoveWait();
    virtual float StepHeight() const { return 18.0f; }
    float GetStepDownMultiplier() const;
    virtual float GetMaxJumpSpeed() const { return 350.0f; }
    virtual float GetJumpGravity() const { return 1.0f; }

    //---------------------------------

    virtual bool OverrideMove(
        float flInterval);  // Override to take total control of movement
                            // (return true if done so)
    virtual bool OverrideMoveFacing(const AILocalMoveGoal_t &move,
                                    float flInterval);

    //---------------------------------

    virtual bool IsUnusableNode(
        int iNodeID, CAI_Hint *pHint);  // Override for special NPC behavior
    virtual bool ValidateNavGoal();
    virtual bool IsCurTaskContinuousMove();
    virtual bool IsValidMoveAwayDest(const Vector &vecDest) { return true; }

    //---------------------------------
    //
    // Notifications from navigator
    //
    virtual void OnMovementFailed(){};
    virtual void OnMovementComplete(){};

    //---------------------------------

    bool FindNearestValidGoalPos(const Vector &vTestPoint, Vector *pResult);

    void RememberUnreachable(
        CBaseEntity *pEntity,
        float duration = -1);  // Remember that entity is unreachable
    virtual bool IsUnreachable(
        CBaseEntity *pEntity);  // Is entity is unreachable?

    //---------------------------------
    // Inherited from IAI_MotorMovementServices
    virtual float CalcYawSpeed(void);

    virtual bool OnCalcBaseMove(AILocalMoveGoal_t *pMoveGoal, float distClear,
                                AIMoveResult_t *pResult);

    virtual bool OnObstructionPreSteer(AILocalMoveGoal_t *pMoveGoal,
                                       float distClear,
                                       AIMoveResult_t *pResult);

    // Translations of the above into some useful game terms
    virtual bool OnObstructingDoor(AILocalMoveGoal_t *pMoveGoal,
                                   CBaseDoor *pDoor, float distClear,
                                   AIMoveResult_t *pResult);

    virtual bool OnUpcomingPropDoor(AILocalMoveGoal_t *pMoveGoal,
                                    CBasePropDoor *pDoor, float distClear,
                                    AIMoveResult_t *pResult);

    void OpenPropDoorBegin(CBasePropDoor *pDoor);
    void OpenPropDoorNow(CBasePropDoor *pDoor);

    //---------------------------------

    void DelayMoveStart(float delay) {
        m_flMoveWaitFinished = gpGlobals->curtime + delay;
    }

    float m_flMoveWaitFinished;

    //
    // Stuff for opening doors.
    //
    void OnDoorFullyOpen(CBasePropDoor *pDoor);
    void OnDoorBlocked(CBasePropDoor *pDoor);
    CHandle<CBasePropDoor>
        m_hOpeningDoor;  // The CBasePropDoor that we are in the midst of
                         // opening for navigation.

   protected:
    // BRJ 4/11
    // Semi-obsolete-looking Lars code I moved out of the engine and into here
    int FlyMove(const Vector &vecPosition, unsigned int mask);
    int WalkMove(const Vector &vecPosition, unsigned int mask);

    //  Unreachable Entities
    CUtlVector<UnreachableEnt_t>
        m_UnreachableEnts;  // Array of unreachable entities

   private:
    CAI_Navigator *m_pNavigator;
    CAI_LocalNavigator *m_pLocalNavigator;
    CAI_Pathfinder *m_pPathfinder;
    CAI_MoveProbe *m_pMoveProbe;
    CAI_Motor *m_pMotor;

    EHANDLE m_hGoalEnt;  // path corner we are heading towards

    float m_flTimeLastMovement;

    CSimpleSimTimer m_CheckOnGroundTimer;

   public:
    //-----------------------------------------------------
    //
    // Eye position, view offset, head direction, eye direction
    //
    //-----------------------------------------------------

    void SetDefaultEyeOffset(void);
    const Vector &GetDefaultEyeOffset(void) { return m_vDefaultEyeOffset; }
    virtual Vector GetNodeViewOffset() { return GetViewOffset(); }

    virtual Vector EyeOffset(Activity nActivity);
    virtual Vector EyePosition(void);

    //---------------------------------

    virtual Vector HeadDirection2D(void);
    virtual Vector HeadDirection3D(void);
    virtual Vector EyeDirection2D(void);
    virtual Vector EyeDirection3D(void);

    virtual CBaseEntity *EyeLookTarget(
        void);  // Overridden by subclass to force look at an entity
    virtual void AddLookTarget(CBaseEntity *pTarget, float flImportance,
                               float flDuration, float flRamp = 0.0){};
    virtual void AddLookTarget(const Vector &vecPosition, float flImportance,
                               float flDuration, float flRamp = 0.0){};
    virtual void SetHeadDirection(const Vector &vTargetPos, float flInterval);
    virtual void MaintainLookTargets(float flInterval);
    virtual bool ValidEyeTarget(const Vector &lookTargetPos);

    virtual Vector FacingPosition(void) {
        return EyePosition();
    };  // position that other npc's use when facing you

    virtual void MaintainTurnActivity(void);

    virtual bool FInAimCone(const Vector &vecSpot);
    virtual void AimGun();
    virtual void SetAim(const Vector &aimDir);
    virtual void RelaxAim(void);
    virtual CBaseEntity *GetAlternateMoveShootTarget() { return NULL; }

   protected:
    Vector m_vDefaultEyeOffset;
    float m_flNextEyeLookTime;  // Next time a pick a new place to look

    float m_flEyeIntegRate;  // How fast does eye move to target

   private:
    Vector m_vEyeLookTarget;   // Where I want to be looking
    Vector m_vCurEyeTarget;    // Direction I'm looking at
    EHANDLE m_hEyeLookTarget;  // What I want to be looking at
    float m_flHeadYaw;         // Current head yaw
    float m_flHeadPitch;       // Current head pitch
   protected:
    float m_flOriginalYaw;  // This is the direction facing when the level
                            // designer placed the NPC in the level.

   public:
    //-----------------------------------------------------
    // Mapmaker Scripting
    //
    // Set when the NPC is being scripted by a mapmaker, and
    // shouldn't be responding to external stimuli that would
    // break him out of his "script". NOT a scripted sequence.
    //-----------------------------------------------------
    inline bool IsInAScript(void) { return m_bInAScript; }
    inline void SetInAScript(bool bScript) { m_bInAScript = bScript; }
    void InputStartScripting(inputdata_t &inputdata) { m_bInAScript = true; }
    void InputStopScripting(inputdata_t &inputdata) { m_bInAScript = false; }

    void InputGagEnable(inputdata_t &inputdata) { AddSpawnFlags(SF_NPC_GAG); }
    void InputGagDisable(inputdata_t &inputdata) {
        RemoveSpawnFlags(SF_NPC_GAG);
    }

    bool HandleInteraction(int interactionType, void *data,
                           CBaseCombatCharacter *sourceEnt);

    virtual void InputOutsideTransition(inputdata_t &inputdata);
    virtual void InputInsideTransition(inputdata_t &inputdata);

    void CleanupScriptsOnTeleport(bool bEnrouteAsWell);

    virtual void SetScriptedScheduleIgnoreConditions(
        Interruptability_t interrupt);

   private:
    bool m_bInAScript;

   public:
    //-----------------------------------------------------
    //
    // Scripting
    //
    //-----------------------------------------------------

    // Scripted sequence Info
    enum SCRIPTSTATE {
        SCRIPT_PLAYING = 0,  // Playing the action animation.
        SCRIPT_WAIT,  // Waiting on everyone in the script to be ready. Plays
                      // the pre idle animation if there is one.
        SCRIPT_POST_IDLE,  // Playing the post idle animation after playing the
                           // action animation.
        SCRIPT_CLEANUP,    // Cancelling the script / cleaning up.
        SCRIPT_WALK_TO_MARK,  // Walking to the scripted sequence position.
        SCRIPT_RUN_TO_MARK,   // Running to the scripted sequence position.
        SCRIPT_CUSTOM_MOVE_TO_MARK,  // Moving to the scripted sequence position
                                     // while playing a custom movement
                                     // animation.
    };

    bool ExitScriptedSequence();
    bool CineCleanup();

    virtual void Teleport(const Vector *newPosition, const QAngle *newAngles,
                          const Vector *newVelocity);

    // forces movement and sets a new schedule
    virtual bool ScheduledMoveToGoalEntity(int scheduleType,
                                           CBaseEntity *pGoalEntity,
                                           Activity movementActivity);
    virtual bool ScheduledFollowPath(int scheduleType, CBaseEntity *pPathStart,
                                     Activity movementActivity);

    static void ForceSelectedGo(CBaseEntity *pPlayer, const Vector &targetPos,
                                const Vector &traceDir, bool bRun);
    static void ForceSelectedGoRandom(void);

    bool AutoMovement(CBaseEntity *pTarget = NULL,
                      AIMoveTrace_t *pTraceResult = NULL);
    bool AutoMovement(float flInterval, CBaseEntity *pTarget = NULL,
                      AIMoveTrace_t *pTraceResult = NULL);
    bool TaskRanAutomovement(void) {
        return m_ScheduleState.bTaskRanAutomovement;
    }

    SCRIPTSTATE m_scriptState;  // internal cinematic state
    CHandle<CAI_ScriptedSequence> m_hCine;
    Activity m_ScriptArrivalActivity;
    string_t m_strScriptArrivalSequence;

    //-----------------------------------------------------
    //
    // Scenes
    //
    //-----------------------------------------------------

    void AddSceneLock(float flDuration = 0.2f) {
        m_flSceneTime = MAX(gpGlobals->curtime + flDuration, m_flSceneTime);
    };
    void ClearSceneLock(float flDuration = 0.2f) {
        m_flSceneTime = gpGlobals->curtime + flDuration;
    };
    bool IsInLockedScene(void) { return m_flSceneTime > gpGlobals->curtime; };
    float m_flSceneTime;
    string_t m_iszSceneCustomMoveSeq;

   public:
    //-----------------------------------------------------
    //
    // Memory
    //
    //-----------------------------------------------------

    inline void Remember(int iMemory) { m_afMemory |= iMemory; }
    inline void Forget(int iMemory) { m_afMemory &= ~iMemory; }
    inline bool HasMemory(int iMemory) {
        if (m_afMemory & iMemory) return TRUE;
        return FALSE;
    }
    inline bool HasAllMemories(int iMemory) {
        if ((m_afMemory & iMemory) == iMemory) return TRUE;
        return FALSE;
    }

    virtual CAI_Enemies *GetEnemies(void);
    virtual void RemoveMemory(void);

    virtual bool UpdateEnemyMemory(CBaseEntity *pEnemy, const Vector &position,
                                   CBaseEntity *pInformer = NULL);
    virtual float GetReactionDelay(CBaseEntity *pEnemy);

    void SetLastAttackTime(float time) { m_flLastAttackTime = time; }

    float GetLastAttackTime() const { return m_flLastAttackTime; }
    float GetLastDamageTime() const { return m_flLastDamageTime; }
    float GetLastPlayerDamageTime() const { return m_flLastPlayerDamageTime; }
    float GetLastEnemyTime() const { return m_flLastEnemyTime; }

    // Set up the shot regulator based on the equipped weapon
    virtual void OnChangeActiveWeapon(CBaseCombatWeapon *pOldWeapon,
                                      CBaseCombatWeapon *pNewWeapon);

    // Weapon holstering
    virtual bool CanHolsterWeapon(void);
    virtual int HolsterWeapon(void);
    virtual int UnholsterWeapon(void);
    void InputHolsterWeapon(inputdata_t &inputdata);
    void InputHolsterAndDestroyWeapon(inputdata_t &inputdata);
    void InputUnholsterWeapon(inputdata_t &inputdata);
    bool IsWeaponHolstered(void);
    bool IsWeaponStateChanging(void);
    void SetDesiredWeaponState(DesiredWeaponState_t iState) {
        m_iDesiredWeaponState = iState;
    }

    // NOTE: The Shot Regulator is used to manage the RangeAttack1 weapon.
    inline CAI_ShotRegulator *GetShotRegulator() { return &m_ShotRegulator; }
    virtual void OnRangeAttack1();

   protected:
    // Shot regulator code
    virtual void OnUpdateShotRegulator();

   protected:
    CAI_Enemies *m_pEnemies;  // Holds information about enemies / danger
                              // positions / shared between sqaud members
    int m_afMemory;
    EHANDLE m_hEnemyOccluder;  // The entity my enemy is hiding behind.

    float m_flSumDamage;       // How much consecutive damage I've received
    float m_flLastDamageTime;  // Last time I received damage
    float m_flLastPlayerDamageTime;  // Last time I received damage from the
                                     // player
    float m_flLastSawPlayerTime;     // Last time I saw the player
    float m_flLastAttackTime;  // Last time that I attacked my current enemy
    float m_flLastEnemyTime;
    float m_flNextWeaponSearchTime;  // next time to search for a better weapon
    string_t
        m_iszPendingWeapon;  // THe NPC should create and equip this weapon.
    bool m_bIgnoreUnseenEnemies;

   private:
    CAI_ShotRegulator m_ShotRegulator;  // When should I shoot next?

    DesiredWeaponState_t m_iDesiredWeaponState;

   public:
    //-----------------------------------------------------
    //
    // Squads & tactics
    //
    //-----------------------------------------------------

    virtual bool InitSquad(void);

    virtual const char *SquadSlotName(int slotID) {
        return gm_SquadSlotNamespace.IdToSymbol(slotID);
    }
    bool OccupyStrategySlot(int squadSlotID);
    bool OccupyStrategySlotRange(int slotIDStart, int slotIDEnd);
    bool HasStrategySlot(int squadSlotID);
    bool HasStrategySlotRange(int slotIDStart, int slotIDEnd);
    int GetMyStrategySlot() { return m_iMySquadSlot; }
    void VacateStrategySlot(void);
    bool IsStrategySlotRangeOccupied(
        int slotIDStart,
        int slotIDEnd);  // Returns true if all in the range are occupied

    CAI_Squad *GetSquad() { return m_pSquad; }
    virtual void SetSquad(CAI_Squad *pSquad);
    void AddToSquad(string_t name);
    void RemoveFromSquad();
    void CheckSquad();
    void SetSquadName(string_t name) { m_SquadName = name; }
    bool IsInSquad() const { return m_pSquad != NULL; }
    virtual bool IsSilentSquadMember() const { return false; }

    int NumWeaponsInSquad(const char *pszWeaponClassname);

    string_t GetHintGroup(void) { return m_strHintGroup; }
    void ClearHintGroup(void) { SetHintGroup(NULL_STRING); }
    void SetHintGroup(string_t name, bool bHintGroupNavLimiting = false);
    bool IsLimitingHintGroups(void) { return m_bHintGroupNavLimiting; }

    //---------------------------------

    CAI_TacticalServices *GetTacticalServices() { return m_pTacticalServices; }
    const CAI_TacticalServices *GetTacticalServices() const {
        return m_pTacticalServices;
    }

    //---------------------------------
    //  Cover

    virtual bool FindCoverPos(CBaseEntity *pEntity, Vector *pResult);
    virtual bool FindCoverPosInRadius(CBaseEntity *pEntity,
                                      const Vector &goalPos, float coverRadius,
                                      Vector *pResult);
    virtual bool FindCoverPos(CSound *pSound, Vector *pResult);
    virtual bool IsValidCover(const Vector &vecCoverLocation,
                              CAI_Hint const *pHint);
    virtual bool IsValidShootPosition(const Vector &vecCoverLocation,
                                      CAI_Node *pNode, CAI_Hint const *pHint);
    virtual bool TestShootPosition(const Vector &vecShootPos,
                                   const Vector &targetPos) {
        return WeaponLOSCondition(vecShootPos, targetPos, false);
    }
    virtual bool IsCoverPosition(const Vector &vecThreat,
                                 const Vector &vecPosition);
    virtual float CoverRadius(void) { return 1024; }  // Default cover radius
    virtual float GetMaxTacticalLateralMovement(void) {
        return MAXTACLAT_IGNORE;
    }

   protected:
    virtual void OnChangeHintGroup(string_t oldGroup, string_t newGroup) {}

    CAI_Squad *m_pSquad;  // The squad that I'm on
    string_t m_SquadName;

    int m_iMySquadSlot;  // this is the behaviour slot that the npc currently
                         // holds in the squad.

   private:
    string_t m_strHintGroup;
    bool m_bHintGroupNavLimiting;
    CAI_TacticalServices *m_pTacticalServices;

   public:
    //-----------------------------------------------------
    //
    // Base schedule & task support; Miscellaneous
    //
    //-----------------------------------------------------

    void InitRelationshipTable(void);
    void AddRelationship(const char *pszRelationship, CBaseEntity *pActivator);

    virtual void AddEntityRelationship(CBaseEntity *pEntity,
                                       Disposition_t nDisposition,
                                       int nPriority);
    virtual void AddClassRelationship(Class_T nClass,
                                      Disposition_t nDisposition,
                                      int nPriority);

    void NPCUse(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType,
                float value);

    CBaseGrenade *IncomingGrenade(void);

    virtual bool ShouldFadeOnDeath(void);

    void NPCInitDead(void);  // Call after animation/pose is set up
    void CorpseFallThink(void);

    float ThrowLimit(const Vector &vecStart, const Vector &vecEnd,
                     float fGravity, float fArcSize, const Vector &mins,
                     const Vector &maxs, CBaseEntity *pTarget, Vector *jumpVel,
                     CBaseEntity **pBlocker);

    // these functions will survey conditions and set appropriate conditions
    // bits for attack types.
    virtual int RangeAttack1Conditions(float flDot, float flDist);
    virtual int RangeAttack2Conditions(float flDot, float flDist);
    virtual int MeleeAttack1Conditions(float flDot, float flDist);
    virtual int MeleeAttack2Conditions(float flDot, float flDist);

    virtual float InnateRange1MinRange(void) { return 0.0f; }
    virtual float InnateRange1MaxRange(void) { return FLT_MAX; }

    virtual bool OnBeginMoveAndShoot(void) { return true; }
    virtual void OnEndMoveAndShoot(void) {}

    virtual bool UseAttackSquadSlots() { return false; }

    //---------------------------------

    virtual CBaseEntity *FindNamedEntity(const char *pszName,
                                         IEntityFindFilter *pFilter = NULL);

    //---------------------------------
    //  States
    //---------------------------------

    virtual void ClearAttackConditions(void);
    void GatherAttackConditions(CBaseEntity *pTarget, float flDist);
    virtual bool ShouldLookForBetterWeapon();
    bool Weapon_IsBetterAvailable(void);
    virtual Vector Weapon_ShootPosition(void);
    virtual void GiveWeapon(string_t iszWeaponName);
    virtual void OnGivenWeapon(CBaseCombatWeapon *pNewWeapon) {}
    bool IsMovingToPickupWeapon();
    virtual bool WeaponLOSCondition(const Vector &ownerPos,
                                    const Vector &targetPos,
                                    bool bSetConditions);
    virtual bool CurrentWeaponLOSCondition(const Vector &targetPos,
                                           bool bSetConditions) {
        return WeaponLOSCondition(GetAbsOrigin(), targetPos, bSetConditions);
    }
    virtual bool IsWaitingToRappel(void) { return false; }
    virtual void BeginRappel() {}

    // override to change the chase location of an enemy
    // This is where your origin should go when you are chasing pEnemy when his
    // origin is at chasePosition by default, leave this alone to make your
    // origin coincide with his.
    virtual void TranslateNavGoal(CBaseEntity *pEnemy, Vector &chasePosition);
    virtual float GetDefaultNavGoalTolerance() {
        return (GetHullWidth() * 2.0);
    }

    virtual bool FCanCheckAttacks(void);
    virtual void CheckAmmo(void) {}

    virtual bool FValidateHintType(CAI_Hint *pHint);
    virtual Activity GetHintActivity(short sHintType, Activity HintsActivity);
    virtual float GetHintDelay(short sHintType);
    virtual Activity GetCoverActivity(CAI_Hint *pHint);
    virtual Activity GetReloadActivity(CAI_Hint *pHint);

    virtual void SetTurnActivity(void);
    bool UpdateTurnGesture(void);

    // Returns the time when the door will be open
    float OpenDoorAndWait(CBaseEntity *pDoor);

    bool BBoxFlat(void);

    //---------------------------------

    virtual void Ignite(float flFlameLifetime, bool bNPCOnly = true,
                        float flSize = 0.0f,
                        bool bCalledByLevelDesigner = false);
    virtual bool PassesDamageFilter(const CTakeDamageInfo &info);

    //---------------------------------

    void MakeDamageBloodDecal(int cCount, float flNoise, trace_t *ptr,
                              Vector vecDir);
    virtual float GetHitgroupDamageMultiplier(int iHitGroup,
                                              const CTakeDamageInfo &info);
    void TraceAttack(const CTakeDamageInfo &info, const Vector &vecDir,
                     trace_t *ptr, CDmgAccumulator *pAccumulator);
    void DecalTrace(trace_t *pTrace, char const *decalName);
    void ImpactTrace(trace_t *pTrace, int iDamageType,
                     const char *pCustomImpactName);
    virtual bool PlayerInSpread(const Vector &sourcePos,
                                const Vector &targetPos, float flSpread,
                                float maxDistOffCenter,
                                bool ignoreHatedPlayers = true);
    CBaseEntity *PlayerInRange(const Vector &vecLocation, float flDist);
    bool PointInSpread(CBaseCombatCharacter *pCheckEntity,
                       const Vector &sourcePos, const Vector &targetPos,
                       const Vector &testPoint, float flSpread,
                       float maxDistOffCenter);
    bool IsSquadmateInSpread(const Vector &sourcePos, const Vector &targetPos,
                             float flSpread, float maxDistOffCenter);

    //---------------------------------
    // combat functions
    //---------------------------------
    virtual bool InnateWeaponLOSCondition(const Vector &ownerPos,
                                          const Vector &targetPos,
                                          bool bSetConditions);

    virtual Activity GetFlinchActivity(bool bHeavyDamage, bool bGesture);

    virtual bool Event_Gibbed(const CTakeDamageInfo &info);
    virtual void Event_Killed(const CTakeDamageInfo &info);

    virtual Vector GetShootEnemyDir(const Vector &shootOrigin,
                                    bool bNoisy = true);
#ifdef HL2_DLL
    virtual Vector GetActualShootPosition(const Vector &shootOrigin);
    virtual Vector GetActualShootTrajectory(const Vector &shootOrigin);
    virtual Vector GetAttackSpread(CBaseCombatWeapon *pWeapon,
                                   CBaseEntity *pTarget = NULL);
    virtual float GetSpreadBias(CBaseCombatWeapon *pWeapon,
                                CBaseEntity *pTarget);
#endif  // HL2_DLL
    virtual void CollectShotStats(const Vector &vecShootOrigin,
                                  const Vector &vecShootDir);
    virtual Vector BodyTarget(const Vector &posSrc, bool bNoisy = true);
    virtual Vector GetAutoAimCenter() { return BodyTarget(vec3_origin, false); }
    virtual void FireBullets(const FireBulletsInfo_t &info);

    // OLD VERSION! Use the struct version
    void FireBullets(int cShots, const Vector &vecSrc,
                     const Vector &vecDirShooting, const Vector &vecSpread,
                     float flDistance, int iAmmoType, int iTracerFreq = 4,
                     int firingEntID = -1, int attachmentID = -1,
                     int iDamage = 0, CBaseEntity *pAttacker = NULL,
                     bool bFirstShotAccurate = false);

    virtual bool ShouldMoveAndShoot(void);

    //---------------------------------
    //  Damage
    //---------------------------------
    virtual int OnTakeDamage_Alive(const CTakeDamageInfo &info);
    virtual int OnTakeDamage_Dying(const CTakeDamageInfo &info);
    virtual int OnTakeDamage_Dead(const CTakeDamageInfo &info);

    virtual void NotifyFriendsOfDamage(CBaseEntity *pAttackerEntity);
    virtual void OnFriendDamaged(CBaseCombatCharacter *pSquadmate,
                                 CBaseEntity *pAttacker);

    virtual bool IsLightDamage(const CTakeDamageInfo &info);
    virtual bool IsHeavyDamage(const CTakeDamageInfo &info);

    void DoRadiusDamage(const CTakeDamageInfo &info, int iClassIgnore,
                        CBaseEntity *pEntityIgnore);
    void DoRadiusDamage(const CTakeDamageInfo &info, const Vector &vecSrc,
                        int iClassIgnore, CBaseEntity *pEntityIgnore);

    //---------------------------------

    virtual void PickupWeapon(CBaseCombatWeapon *pWeapon);
    virtual void PickupItem(CBaseEntity *pItem){};
    CBaseEntity *DropItem(const char *pszItemName, Vector vecPos,
                          QAngle vecAng);  // drop an item.

    //---------------------------------
    // Inputs
    //---------------------------------
    void InputSetRelationship(inputdata_t &inputdata);
    void InputSetEnemyFilter(inputdata_t &inputdata);
    void InputSetHealth(inputdata_t &inputdata);
    void InputBeginRappel(inputdata_t &inputdata);
    void InputSetSquad(inputdata_t &inputdata);
    void InputWake(inputdata_t &inputdata);
    void InputForgetEntity(inputdata_t &inputdata);
    void InputIgnoreDangerSounds(inputdata_t &inputdata);
    void InputUpdateEnemyMemory(inputdata_t &inputdata);

    //---------------------------------

    virtual void NotifyDeadFriend(CBaseEntity *pFriend) { return; }

    //---------------------------------
    // Utility methods
    static Vector CalcThrowVelocity(const Vector &startPos,
                                    const Vector &endPos, float fGravity,
                                    float fArcSize);

    //---------------------------------

    float SetWait(float minWait, float maxWait = 0.0);
    void ClearWait();
    float GetWaitFinishTime() { return m_flWaitFinished; }
    bool IsWaitFinished();
    bool IsWaitSet();

    CBaseEntity *GetGoalEnt() { return m_hGoalEnt; }
    void SetGoalEnt(CBaseEntity *pGoalEnt) { m_hGoalEnt.Set(pGoalEnt); }

    CAI_Hint *GetHintNode() { return m_pHintNode; }
    const CAI_Hint *GetHintNode() const { return m_pHintNode; }
    void SetHintNode(CAI_Hint *pHintNode);
    void ClearHintNode(float reuseDelay = 0.0);

    float m_flWaitFinished;  // if we're told to wait, this is the time that the
                             // wait will be over.

    float m_flNextFlinchTime;  // Time at which we'll flinch fully again (as
                               // opposed to just doing gesture flinches)
    float m_flNextDodgeTime;   // Time at which I can dodge again. Used so that
                               // the behavior doesn't happen over and over.

    CAI_MoveAndShootOverlay m_MoveAndShootOverlay;

    Vector m_vecLastPosition;  // npc sometimes wants to return to where it
                               // started after an operation.
    Vector
        m_vSavePosition;  // position stored by code that called this schedules
    Vector m_vInterruptSavePosition;  // position stored by a task that was
                                      // interrupted

   private:
    CHandle<CAI_Hint> m_pHintNode;  // this is the hint that the npc is moving
                                    // towards or performing active idle on.

   public:
    int m_cAmmoLoaded;  // how much ammo is in the weapon (used to trigger
                        // reload anim sequences)
    float
        m_flDistTooFar;  // if enemy farther away than this,
                         // bits_COND_ENEMY_TOOFAR set in GatherEnemyConditions
    string_t m_spawnEquipment;

    bool m_fNoDamageDecal;

    EHANDLE m_hStoredPathTarget;   // For TASK_SET_GOAL
    Vector m_vecStoredPathGoal;    //
    GoalType_t m_nStoredPathType;  //
    int m_fStoredPathFlags;        //

    CHandle<CBaseFilter> m_hEnemyFilter;
    string_t m_iszEnemyFilterName;

    bool m_bDidDeathCleanup;

    IMPLEMENT_NETWORK_VAR_FOR_DERIVED(m_lifeState);

    //---------------------------------
    //	Outputs
    //---------------------------------
    COutputEvent m_OnDamaged;
    COutputEvent m_OnDeath;
    COutputEvent m_OnHalfHealth;
    COutputEHANDLE m_OnFoundEnemy;
    COutputEvent m_OnLostEnemyLOS;
    COutputEvent m_OnLostEnemy;
    COutputEHANDLE m_OnFoundPlayer;
    COutputEvent m_OnLostPlayerLOS;
    COutputEvent m_OnLostPlayer;
    COutputEvent m_OnHearWorld;
    COutputEvent m_OnHearPlayer;
    COutputEvent m_OnHearCombat;
    COutputEvent m_OnDamagedByPlayer;
    COutputEvent m_OnDamagedByPlayerSquad;
    COutputEvent m_OnDenyCommanderUse;
    COutputEvent m_OnRappelTouchdown;
    COutputEvent m_OnSleep;
    COutputEvent m_OnWake;
    COutputEvent m_OnForcedInteractionStarted;
    COutputEvent m_OnForcedInteractionAborted;
    COutputEvent m_OnForcedInteractionFinished;

   public:
    // use this to shrink the bbox temporarily
    void SetHullSizeNormal(bool force = false);
    bool SetHullSizeSmall(bool force = false);

    bool IsUsingSmallHull() const { return m_fIsUsingSmallHull; }

    const Vector &GetHullMins() const { return NAI_Hull::Mins(GetHullType()); }
    const Vector &GetHullMaxs() const { return NAI_Hull::Maxs(GetHullType()); }
    float GetHullWidth() const { return NAI_Hull::Width(GetHullType()); }
    float GetHullHeight() const { return NAI_Hull::Height(GetHullType()); }

    void SetupVPhysicsHull();
    virtual void StartTouch(CBaseEntity *pOther);
    void CheckPhysicsContacts();

   private:
    void TryRestoreHull(void);
    bool m_fIsUsingSmallHull;
    bool m_bCheckContacts;

   private:
    // Task implementation helpers
    void StartTurn(float flDeltaYaw);
    bool FindCoverFromEnemy(bool bNodesOnly = false, float flMinDistance = 0,
                            float flMaxDistance = FLT_MAX);
    bool FindCoverFromBestSound(Vector *pCoverPos);
    void StartScriptMoveToTargetTask(int task);

    void RunDieTask();
    void RunAttackTask(int task);

   protected:
    virtual float CalcReasonableFacing(bool bIgnoreOriginalFacing = false);
    virtual bool IsValidReasonableFacing(const Vector &vecSightDir,
                                         float sightDist) {
        return true;
    }
    virtual float GetReasonableFacingDist(void);

   public:
    inline int UsableNPCObjectCaps(int baseCaps) {
        if (IsAlive()) baseCaps |= FCAP_IMPULSE_USE;
        return baseCaps;
    }

    virtual int ObjectCaps() {
        return (BaseClass::ObjectCaps() | FCAP_NOTIFY_ON_TRANSITION);
    }

    //-----------------------------------------------------
    //
    // Core mapped data structures
    //
    // String Registries for default AI Shared by all CBaseNPCs
    //	These are used only during initialization and in debug
    //-----------------------------------------------------

    static void InitSchedulingTables();

    static CAI_GlobalScheduleNamespace *GetSchedulingSymbols() {
        return &gm_SchedulingSymbols;
    }
    static CAI_ClassScheduleIdSpace &AccessClassScheduleIdSpaceDirect() {
        return gm_ClassScheduleIdSpace;
    }
    virtual CAI_ClassScheduleIdSpace *GetClassScheduleIdSpace() {
        return &gm_ClassScheduleIdSpace;
    }

    static int GetScheduleID(const char *schedName);
    static int GetActivityID(const char *actName);
    static int GetConditionID(const char *condName);
    static int GetTaskID(const char *taskName);
    static int GetSquadSlotID(const char *slotName);
    virtual const char *GetSquadSlotDebugName(int iSquadSlot);
    static const char *GetActivityName(int actID);

    static void AddActivityToSR(const char *actName, int conID);

    static void AddEventToSR(const char *eventName, int conID);
    static const char *GetEventName(int actID);
    static int GetEventID(const char *actName);

   public:
    //-----------------------------------------------------
    // Crouch handling
    //-----------------------------------------------------
    bool CrouchIsDesired(void) const;
    virtual bool IsCrouching(void);
    inline void ForceCrouch(void);
    inline void ClearForceCrouch(void);

   protected:
    virtual bool Crouch(void);
    virtual bool Stand(void);
    virtual void DesireCrouch(void);
    inline void DesireStand(void);
    bool CouldShootIfCrouching(CBaseEntity *pTarget);
    virtual bool IsCrouchedActivity(Activity activity);

   protected:
    // Override these in your derived NPC class
    virtual Vector GetCrouchEyeOffset(void) { return Vector(0, 0, 40); }
    virtual Vector GetCrouchGunOffset(void) { return Vector(0, 0, 36); }

   private:
    bool m_bCrouchDesired;
    bool m_bForceCrouch;
    bool m_bIsCrouching;
    //-----------------------------------------------------

    //-----------------------------------------------------
    // ai_post_frame_navigation
    //-----------------------------------------------------

   private:
    bool m_bDeferredNavigation;  // This NPCs has a navigation query that's
                                 // being deferred until later in the frame

   public:
    void SetNavigationDeferred(bool bState) { m_bDeferredNavigation = bState; }
    bool IsNavigationDeferred(void) { return m_bDeferredNavigation; }

    //-----------------------------------------------------
   protected:
    static CAI_GlobalNamespace gm_SquadSlotNamespace;
    static CAI_LocalIdSpace gm_SquadSlotIdSpace;

   private:
    // Checks to see that the nav hull is valid for the NPC
    bool IsNavHullValid() const;

    friend class CAI_SystemHook;
    friend class CAI_SchedulesManager;

    static bool LoadDefaultSchedules(void);

    static void InitDefaultScheduleSR(void);
    static void InitDefaultTaskSR(void);
    static void InitDefaultConditionSR(void);
    static void InitDefaultActivitySR(void);
    static void InitDefaultSquadSlotSR(void);

    static CStringRegistry *m_pActivitySR;
    static int m_iNumActivities;

    static CStringRegistry *m_pEventSR;
    static int m_iNumEvents;

    static CAI_GlobalScheduleNamespace gm_SchedulingSymbols;
    static CAI_ClassScheduleIdSpace gm_ClassScheduleIdSpace;

   public:
    //----------------------------------------------------
    // Debugging tools
    //

    // -----------------------------
    //  Debuging Fields and Methods
    // -----------------------------
    const char *m_failText;            // Text of why it failed
    const char *m_interruptText;       // Text of why schedule interrupted
    CAI_Schedule *m_failedSchedule;    // The schedule that failed last
    CAI_Schedule *m_interuptSchedule;  // The schedule that was interrupted last
    int m_nDebugCurIndex;              // Index used for stepping through AI
    virtual void ReportAIState(void);
    virtual void ReportOverThinkLimit(float time);
    void DumpTaskTimings();
    void DrawDebugGeometryOverlays(void);
    virtual int DrawDebugTextOverlays(void);
    void ToggleFreeze(void);

    static void ClearAllSchedules(void);

    static int m_nDebugBits;

    static CAI_BaseNPC *m_pDebugNPC;
    static int m_nDebugPauseIndex;  // Current step
    static inline void SetDebugNPC(CAI_BaseNPC *pNPC) { m_pDebugNPC = pNPC; }
    static inline bool IsDebugNPC(CAI_BaseNPC *pNPC) {
        return (pNPC == m_pDebugNPC);
    }

    float m_LastShootAccuracy;
    int m_TotalShots;
    int m_TotalHits;
#ifdef _DEBUG
    bool m_bSelected;
#endif

    float m_flSoundWaitTime;  // Time when I'm allowed to make another sound
    int m_nSoundPriority;
    float m_flIgnoreDangerSoundsUntil;

#ifdef AI_MONITOR_FOR_OSCILLATION
    CUtlVector<AIScheduleChoice_t> m_ScheduleHistory;
#endif  // AI_MONITOR_FOR_OSCILLATION

   private:
    // Break into pieces!
    void Break(CBaseEntity *pBreaker);
    void InputBreak(inputdata_t &inputdata);

    friend void CC_NPC_Go();
    friend void CC_NPC_GoRandom();
    friend void CC_NPC_Freeze(const CCommand &args);

   public:
    CNetworkVar(bool, m_bPerformAvoidance);
    CNetworkVar(bool, m_bIsMoving);
    CNetworkVar(bool, m_bFadeCorpse);
    CNetworkVar(bool, m_bImportanRagdoll);

    CNetworkVar(bool, m_bSpeedModActive);
    CNetworkVar(int, m_iSpeedModRadius);
    CNetworkVar(int, m_iSpeedModSpeed);
    CNetworkVar(
        float,
        m_flTimePingEffect);  // Display the pinged effect until this time

    void InputActivateSpeedModifier(inputdata_t &inputdata) {
        m_bSpeedModActive = true;
    }
    void InputDisableSpeedModifier(inputdata_t &inputdata) {
        m_bSpeedModActive = false;
    }
    void InputSetSpeedModifierRadius(inputdata_t &inputdata);
    void InputSetSpeedModifierSpeed(inputdata_t &inputdata);

    virtual bool ShouldProbeCollideAgainstEntity(CBaseEntity *pEntity);

    bool m_bPlayerAvoidState;
    void GetPlayerAvoidBounds(Vector *pMins, Vector *pMaxs);

    void StartPingEffect(void) {
        m_flTimePingEffect = gpGlobals->curtime + 2.0f;
        DispatchUpdateTransmitState();
    }
};

//-----------------------------------------------------------------------------
// Purpose: Returns whether our ideal activity has started. If not, we are in
//			a transition sequence.
//-----------------------------------------------------------------------------
inline bool CAI_BaseNPC::IsActivityStarted(void) {
    return (GetSequence() == m_nIdealSequence);
}

//-----------------------------------------------------------------------------
// Bullet firing (legacy)...
//-----------------------------------------------------------------------------
inline void CAI_BaseNPC::FireBullets(int cShots, const Vector &vecSrc,
                                     const Vector &vecDirShooting,
                                     const Vector &vecSpread, float flDistance,
                                     int iAmmoType, int iTracerFreq,
                                     int firingEntID, int attachmentID,
                                     int iDamage, CBaseEntity *pAttacker,
                                     bool bFirstShotAccurate) {
    FireBulletsInfo_t info;
    info.m_iShots = cShots;
    info.m_vecSrc = vecSrc;
    info.m_vecDirShooting = vecDirShooting;
    info.m_vecSpread = vecSpread;
    info.m_flDistance = flDistance;
    info.m_iAmmoType = iAmmoType;
    info.m_iTracerFreq = iTracerFreq;
    info.m_flDamage = iDamage;
    info.m_pAttacker = pAttacker;
    info.m_nFlags = bFirstShotAccurate ? FIRE_BULLETS_FIRST_SHOT_ACCURATE : 0;

    FireBullets(info);
}

//-----------------------------------------------------------------------------
// Purpose: Sets the ideal state of this NPC.
//-----------------------------------------------------------------------------
inline void CAI_BaseNPC::SetIdealState(NPC_STATE eIdealState) {
    if (eIdealState != m_IdealNPCState) {
        /*switch (eIdealState)
        {
                case NPC_STATE_NONE:
                        Msg("%s.SetIdealState: NPC_STATE_NONE\n",
        GetDebugName()); break;

                case NPC_STATE_IDLE:
                        Msg("%s.SetIdealState: NPC_STATE_IDLE\n",
        GetDebugName()); break;

                case NPC_STATE_ALERT:
                        Msg("%s.SetIdealState: NPC_STATE_ALERT\n",
        GetDebugName()); break;

                case NPC_STATE_COMBAT:
                        Msg("%s.SetIdealState: NPC_STATE_COMBAT\n",
        GetDebugName()); break;

                case NPC_STATE_SCRIPT:
                        Msg("%s.SetIdealState: NPC_STATE_SCRIPT\n",
        GetDebugName()); break;

                case NPC_STATE_PLAYDEAD:
                        Msg("%s.SetIdealState: NPC_STATE_PLAYDEAD\n",
        GetDebugName()); break;

                case NPC_STATE_PRONE:
                        Msg("%s.SetIdealState: NPC_STATE_PRONE\n",
        GetDebugName()); break;

                case NPC_STATE_DEAD:
                        Msg("%s.SetIdealState: NPC_STATE_DEAD\n",
        GetDebugName()); break;

                default:
                        Msg("%s.SetIdealState: <Unknown>\n", GetDebugName());
                        break;
        }*/

        m_IdealNPCState = eIdealState;
    }
}

//-----------------------------------------------------------------------------
// Purpose: Returns the current ideal state the NPC will try to achieve.
//-----------------------------------------------------------------------------
inline NPC_STATE CAI_BaseNPC::GetIdealState() { return m_IdealNPCState; }

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CAI_BaseNPC::IncScheduleCurTaskIndex() {
    m_ScheduleState.iTaskInterrupt = 0;
    m_ScheduleState.bTaskRanAutomovement = false;
    m_ScheduleState.bTaskUpdatedYaw = false;
    return ++m_ScheduleState.iCurTask;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CAI_BaseNPC::ResetScheduleCurTaskIndex() {
    m_ScheduleState.iCurTask = 0;
    m_ScheduleState.iTaskInterrupt = 0;
    m_ScheduleState.bTaskRanAutomovement = false;
    m_ScheduleState.bTaskUpdatedYaw = false;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline bool CAI_BaseNPC::CrouchIsDesired(void) const {
    return ((CapabilitiesGet() & bits_CAP_DUCK) &&
            (m_bCrouchDesired | m_bForceCrouch));
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
inline void CAI_BaseNPC::DesireStand(void) { m_bCrouchDesired = false; }

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
inline void CAI_BaseNPC::ForceCrouch(void) {
    m_bForceCrouch = true;
    Crouch();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
inline void CAI_BaseNPC::ClearForceCrouch(void) {
    m_bForceCrouch = false;

    if (IsCrouching()) {
        Stand();
    }
}

inline bool CAI_BaseNPC::HaveSequenceForActivity(Activity activity) {
#if STUDIO_SEQUENCE_ACTIVITY_LOOKUPS_ARE_SLOW
    return ((GetModelPtr())
                ? (SelectWeightedSequence(activity) != ACTIVITY_NOT_AVAILABLE)
                : false);
#else
    return ((GetModelPtr()) ? GetModelPtr()->HaveSequenceForActivity(activity)
                            : false);
#endif
}

typedef CHandle<CAI_BaseNPC> AIHANDLE;

// ============================================================================
//	Macros for introducing new schedules in sub-classes
//
// Strings registries and schedules use unique ID's for each item, but
// sub-class enumerations are non-unique, so we translate between the
// enumerations and unique ID's
// ============================================================================

#define AI_BEGIN_CUSTOM_SCHEDULE_PROVIDER(derivedClass) \
    IMPLEMENT_CUSTOM_SCHEDULE_PROVIDER(derivedClass)    \
    void derivedClass::InitCustomSchedules(void) {      \
        typedef derivedClass CNpc;                      \
        const char *pszClassName = #derivedClass;       \
                                                        \
        CUtlVector<const char *> schedulesToLoad;       \
        CUtlVector<AIScheduleLoadFunc_t> reqiredOthers; \
        CAI_NamespaceInfos scheduleIds;                 \
        CAI_NamespaceInfos taskIds;                     \
        CAI_NamespaceInfos conditionIds;

//-----------------

#define AI_BEGIN_CUSTOM_NPC(className, derivedClass)    \
    IMPLEMENT_CUSTOM_AI(className, derivedClass)        \
    void derivedClass::InitCustomSchedules(void) {      \
        typedef derivedClass CNpc;                      \
        const char *pszClassName = #derivedClass;       \
                                                        \
        CUtlVector<const char *> schedulesToLoad;       \
        CUtlVector<AIScheduleLoadFunc_t> reqiredOthers; \
        CAI_NamespaceInfos scheduleIds;                 \
        CAI_NamespaceInfos taskIds;                     \
        CAI_NamespaceInfos conditionIds;                \
        CAI_NamespaceInfos squadSlotIds;

//-----------------

#define EXTERN_SCHEDULE(id)        \
    scheduleIds.PushBack(#id, id); \
    extern const char *g_psz##id;  \
    schedulesToLoad.AddToTail(g_psz##id);

//-----------------

#define DEFINE_SCHEDULE(id, text)        \
    scheduleIds.PushBack(#id, id);       \
    const char *g_psz##id =              \
        "\n	Schedule"                    \
        "\n		" #id text "\n"; \
    schedulesToLoad.AddToTail(g_psz##id);

//-----------------

#define DECLARE_CONDITION(id) conditionIds.PushBack(#id, id);

//-----------------

#define DECLARE_TASK(id) taskIds.PushBack(#id, id);

//-----------------

#define DECLARE_ACTIVITY(id) ADD_CUSTOM_ACTIVITY(CNpc, id);

//-----------------

#define DECLARE_SQUADSLOT(id) squadSlotIds.PushBack(#id, id);

//-----------------

#define DECLARE_INTERACTION(interaction) ADD_CUSTOM_INTERACTION(interaction);

//-----------------

#define DECLARE_ANIMEVENT(id) ADD_CUSTOM_ANIMEVENT(CNpc, id);

//-----------------

#define DECLARE_USES_SCHEDULE_PROVIDER(classname) \
    reqiredOthers.AddToTail(ScheduleLoadHelper(classname));

//-----------------

// IDs are stored and then added in order due to constraints in the namespace
// implementation
#define AI_END_CUSTOM_SCHEDULE_PROVIDER()                                    \
                                                                             \
    int i;                                                                   \
                                                                             \
    CNpc::AccessClassScheduleIdSpaceDirect().Init(                           \
        pszClassName, BaseClass::GetSchedulingSymbols(),                     \
        &BaseClass::AccessClassScheduleIdSpaceDirect());                     \
                                                                             \
    scheduleIds.Sort();                                                      \
    taskIds.Sort();                                                          \
    conditionIds.Sort();                                                     \
                                                                             \
    for (i = 0; i < scheduleIds.Count(); i++) {                              \
        ADD_CUSTOM_SCHEDULE_NAMED(CNpc, scheduleIds[i].pszName,              \
                                  scheduleIds[i].localId);                   \
    }                                                                        \
                                                                             \
    for (i = 0; i < taskIds.Count(); i++) {                                  \
        ADD_CUSTOM_TASK_NAMED(CNpc, taskIds[i].pszName, taskIds[i].localId); \
    }                                                                        \
                                                                             \
    for (i = 0; i < conditionIds.Count(); i++) {                             \
        if (ValidateConditionLimits(conditionIds[i].pszName)) {              \
            ADD_CUSTOM_CONDITION_NAMED(CNpc, conditionIds[i].pszName,        \
                                       conditionIds[i].localId);             \
        }                                                                    \
    }                                                                        \
                                                                             \
    for (i = 0; i < reqiredOthers.Count(); i++) {                            \
        (*reqiredOthers[i])();                                               \
    }                                                                        \
                                                                             \
    for (i = 0; i < schedulesToLoad.Count(); i++) {                          \
        if (CNpc::gm_SchedLoadStatus.fValid) {                               \
            CNpc::gm_SchedLoadStatus.fValid =                                \
                g_AI_SchedulesManager.LoadSchedulesFromBuffer(               \
                    pszClassName, schedulesToLoad[i],                        \
                    &AccessClassScheduleIdSpaceDirect());                    \
        } else                                                               \
            break;                                                           \
    }                                                                        \
    }

inline bool ValidateConditionLimits(const char *pszNewCondition) {
    int nGlobalConditions =
        CAI_BaseNPC::GetSchedulingSymbols()->NumConditions();
    if (nGlobalConditions >= MAX_CONDITIONS) {
        AssertMsg2(
            0,
            "Exceeded max number of conditions (%d), ignoring condition %s\n",
            MAX_CONDITIONS, pszNewCondition);
        DevWarning(
            "Exceeded max number of conditions (%d), ignoring condition %s\n",
            MAX_CONDITIONS, pszNewCondition);
        return false;
    }
    return true;
}

//-------------------------------------

// IDs are stored and then added in order due to constraints in the namespace
// implementation
#define AI_END_CUSTOM_NPC()                                                  \
                                                                             \
    int i;                                                                   \
                                                                             \
    CNpc::AccessClassScheduleIdSpaceDirect().Init(                           \
        pszClassName, BaseClass::GetSchedulingSymbols(),                     \
        &BaseClass::AccessClassScheduleIdSpaceDirect());                     \
    CNpc::gm_SquadSlotIdSpace.Init(&BaseClass::gm_SquadSlotNamespace,        \
                                   &BaseClass::gm_SquadSlotIdSpace);         \
                                                                             \
    scheduleIds.Sort();                                                      \
    taskIds.Sort();                                                          \
    conditionIds.Sort();                                                     \
    squadSlotIds.Sort();                                                     \
                                                                             \
    for (i = 0; i < scheduleIds.Count(); i++) {                              \
        ADD_CUSTOM_SCHEDULE_NAMED(CNpc, scheduleIds[i].pszName,              \
                                  scheduleIds[i].localId);                   \
    }                                                                        \
                                                                             \
    for (i = 0; i < taskIds.Count(); i++) {                                  \
        ADD_CUSTOM_TASK_NAMED(CNpc, taskIds[i].pszName, taskIds[i].localId); \
    }                                                                        \
                                                                             \
    for (i = 0; i < conditionIds.Count(); i++) {                             \
        if (ValidateConditionLimits(conditionIds[i].pszName)) {              \
            ADD_CUSTOM_CONDITION_NAMED(CNpc, conditionIds[i].pszName,        \
                                       conditionIds[i].localId);             \
        }                                                                    \
    }                                                                        \
                                                                             \
    for (i = 0; i < squadSlotIds.Count(); i++) {                             \
        ADD_CUSTOM_SQUADSLOT_NAMED(CNpc, squadSlotIds[i].pszName,            \
                                   squadSlotIds[i].localId);                 \
    }                                                                        \
                                                                             \
    for (i = 0; i < reqiredOthers.Count(); i++) {                            \
        (*reqiredOthers[i])();                                               \
    }                                                                        \
                                                                             \
    for (i = 0; i < schedulesToLoad.Count(); i++) {                          \
        if (CNpc::gm_SchedLoadStatus.fValid) {                               \
            CNpc::gm_SchedLoadStatus.fValid =                                \
                g_AI_SchedulesManager.LoadSchedulesFromBuffer(               \
                    pszClassName, schedulesToLoad[i],                        \
                    &AccessClassScheduleIdSpaceDirect());                    \
        } else                                                               \
            break;                                                           \
    }                                                                        \
    }

//-------------------------------------

struct AI_NamespaceAddInfo_t {
    AI_NamespaceAddInfo_t(const char *pszName, int localId)
        : pszName(pszName), localId(localId) {}

    const char *pszName;
    int localId;
};

class CAI_NamespaceInfos : public CUtlVector<AI_NamespaceAddInfo_t> {
   public:
    void PushBack(const char *pszName, int localId) {
        AddToTail(AI_NamespaceAddInfo_t(pszName, localId));
    }

    void Sort() { CUtlVector<AI_NamespaceAddInfo_t>::Sort(Compare); }

   private:
    static int __cdecl Compare(const AI_NamespaceAddInfo_t *pLeft,
                               const AI_NamespaceAddInfo_t *pRight) {
        return pLeft->localId - pRight->localId;
    }
};

//-------------------------------------

// Declares the static variables that hold the string registry offset for the
// new subclass as well as the initialization in schedule load functions

struct AI_SchedLoadStatus_t {
    bool fValid;
    int signature;
};

// Load schedules pulled out to support stepping through with debugger
inline bool AI_DoLoadSchedules(bool (*pfnBaseLoad)(),
                               void (*pfnInitCustomSchedules)(),
                               AI_SchedLoadStatus_t *pLoadStatus) {
    (*pfnBaseLoad)();

    if (pLoadStatus->signature !=
        g_AI_SchedulesManager.GetScheduleLoadSignature()) {
        (*pfnInitCustomSchedules)();
        pLoadStatus->fValid = true;
        pLoadStatus->signature =
            g_AI_SchedulesManager.GetScheduleLoadSignature();
    }
    return pLoadStatus->fValid;
}

//-------------------------------------

typedef bool (*AIScheduleLoadFunc_t)();

// @Note (toml 02-16-03): The following class exists to allow us to establish an
// anonymous friendship in DEFINE_CUSTOM_SCHEDULE_PROVIDER. The particulars of
// this implementation is almost entirely defined by bugs in MSVC 6.0
class ScheduleLoadHelperImpl {
   public:
    template <typename T>
    static AIScheduleLoadFunc_t AccessScheduleLoadFunc(T *) {
        return (&T::LoadSchedules);
    }
};

#define ScheduleLoadHelper(type) \
    (ScheduleLoadHelperImpl::AccessScheduleLoadFunc((type *)0))

//-------------------------------------

#define DEFINE_CUSTOM_SCHEDULE_PROVIDER                                   \
    static AI_SchedLoadStatus_t gm_SchedLoadStatus;                       \
    static CAI_ClassScheduleIdSpace gm_ClassScheduleIdSpace;              \
    static const char *gm_pszErrorClassName;                              \
                                                                          \
    static CAI_ClassScheduleIdSpace &AccessClassScheduleIdSpaceDirect() { \
        return gm_ClassScheduleIdSpace;                                   \
    }                                                                     \
    virtual CAI_ClassScheduleIdSpace *GetClassScheduleIdSpace() {         \
        return &gm_ClassScheduleIdSpace;                                  \
    }                                                                     \
    virtual const char *GetSchedulingErrorName() {                        \
        return gm_pszErrorClassName;                                      \
    }                                                                     \
                                                                          \
    static void InitCustomSchedules(void);                                \
                                                                          \
    static bool LoadSchedules(void);                                      \
    virtual bool LoadedSchedules(void);                                   \
                                                                          \
    friend class ScheduleLoadHelperImpl;                                  \
                                                                          \
    class CScheduleLoader {                                               \
       public:                                                            \
        CScheduleLoader();                                                \
    } m_ScheduleLoader;                                                   \
                                                                          \
    friend class CScheduleLoader;

//-------------------------------------

#define DEFINE_CUSTOM_AI                         \
    DEFINE_CUSTOM_SCHEDULE_PROVIDER              \
                                                 \
    static CAI_LocalIdSpace gm_SquadSlotIdSpace; \
                                                 \
    const char *SquadSlotName(int squadSlotID);

//-------------------------------------

#define IMPLEMENT_CUSTOM_SCHEDULE_PROVIDER(derivedClass)                  \
    AI_SchedLoadStatus_t derivedClass::gm_SchedLoadStatus = {true, -1};   \
    CAI_ClassScheduleIdSpace derivedClass::gm_ClassScheduleIdSpace;       \
    const char *derivedClass::gm_pszErrorClassName = #derivedClass;       \
                                                                          \
    derivedClass::CScheduleLoader::CScheduleLoader() {                    \
        derivedClass::LoadSchedules();                                    \
    }                                                                     \
                                                                          \
    /* --------------------------------------------- */                   \
    /* Load schedules for this type of NPC           */                   \
    /* --------------------------------------------- */                   \
    bool derivedClass::LoadSchedules(void) {                              \
        return AI_DoLoadSchedules(derivedClass::BaseClass::LoadSchedules, \
                                  derivedClass::InitCustomSchedules,      \
                                  &derivedClass::gm_SchedLoadStatus);     \
    }                                                                     \
                                                                          \
    bool derivedClass::LoadedSchedules(void) {                            \
        return derivedClass::gm_SchedLoadStatus.fValid;                   \
    }

//-------------------------------------

// Initialize offsets and implement methods for loading and getting squad info
// for the subclass
#define IMPLEMENT_CUSTOM_AI(className, derivedClass)                  \
    IMPLEMENT_CUSTOM_SCHEDULE_PROVIDER(derivedClass)                  \
                                                                      \
    CAI_LocalIdSpace derivedClass::gm_SquadSlotIdSpace;               \
                                                                      \
    /* -------------------------------------------------- */          \
    /* Given squadSlot enumeration return squadSlot name */           \
    /* -------------------------------------------------- */          \
    const char *derivedClass::SquadSlotName(int slotEN) {             \
        return gm_SquadSlotNamespace.IdToSymbol(                      \
            derivedClass::gm_SquadSlotIdSpace.LocalToGlobal(slotEN)); \
    }

//-------------------------------------

#define ADD_CUSTOM_SCHEDULE_NAMED(derivedClass, schedName, schedEN)    \
    if (!derivedClass::AccessClassScheduleIdSpaceDirect().AddSchedule( \
            schedName, schedEN, derivedClass::gm_pszErrorClassName))   \
        return;

#define ADD_CUSTOM_SCHEDULE(derivedClass, schedEN) \
    ADD_CUSTOM_SCHEDULE_NAMED(derivedClass, #schedEN, schedEN)

#define ADD_CUSTOM_TASK_NAMED(derivedClass, taskName, taskEN)      \
    if (!derivedClass::AccessClassScheduleIdSpaceDirect().AddTask( \
            taskName, taskEN, derivedClass::gm_pszErrorClassName)) \
        return;

#define ADD_CUSTOM_TASK(derivedClass, taskEN) \
    ADD_CUSTOM_TASK_NAMED(derivedClass, #taskEN, taskEN)

#define ADD_CUSTOM_CONDITION_NAMED(derivedClass, condName, condEN)      \
    if (!derivedClass::AccessClassScheduleIdSpaceDirect().AddCondition( \
            condName, condEN, derivedClass::gm_pszErrorClassName))      \
        return;

#define ADD_CUSTOM_CONDITION(derivedClass, condEN) \
    ADD_CUSTOM_CONDITION_NAMED(derivedClass, #condEN, condEN)

//-------------------------------------

#define INIT_CUSTOM_AI(derivedClass)                       \
    derivedClass::AccessClassScheduleIdSpaceDirect().Init( \
        #derivedClass, BaseClass::GetSchedulingSymbols(),  \
        &BaseClass::AccessClassScheduleIdSpaceDirect());   \
    derivedClass::gm_SquadSlotIdSpace.Init(                \
        &CAI_BaseNPC::gm_SquadSlotNamespace, &BaseClass::gm_SquadSlotIdSpace);

#define ADD_CUSTOM_INTERACTION(interaction) \
    { interaction = CBaseCombatCharacter::GetInteractionID(); }

#define ADD_CUSTOM_SQUADSLOT_NAMED(derivedClass, squadSlotName, squadSlotEN) \
    if (!derivedClass::gm_SquadSlotIdSpace.AddSymbol(                        \
            squadSlotName, squadSlotEN, "squadslot",                         \
            derivedClass::gm_pszErrorClassName))                             \
        return;

#define ADD_CUSTOM_SQUADSLOT(derivedClass, squadSlotEN) \
    ADD_CUSTOM_SQUADSLOT_NAMED(derivedClass, #squadSlotEN, squadSlotEN)

#define ADD_CUSTOM_ACTIVITY_NAMED(derivedClass, activityName, activityEnum) \
    REGISTER_PRIVATE_ACTIVITY(activityEnum);                                \
    CAI_BaseNPC::AddActivityToSR(activityName, activityEnum);

#define ADD_CUSTOM_ACTIVITY(derivedClass, activityEnum) \
    ADD_CUSTOM_ACTIVITY_NAMED(derivedClass, #activityEnum, activityEnum)

#define ADD_CUSTOM_ANIMEVENT_NAMED(derivedClass, eventName, eventEnum) \
    REGISTER_PRIVATE_ANIMEVENT(eventEnum);                             \
    CAI_BaseNPC::AddEventToSR(eventName, eventEnum);

#define ADD_CUSTOM_ANIMEVENT(derivedClass, eventEnum) \
    ADD_CUSTOM_ANIMEVENT_NAMED(derivedClass, #eventEnum, eventEnum)

//=============================================================================
// class CAI_Component
//=============================================================================

inline const Vector &CAI_Component::GetLocalOrigin() const {
    return GetOuter()->GetLocalOrigin();
}

//-----------------------------------------------------------------------------

inline void CAI_Component::SetLocalOrigin(const Vector &origin) {
    GetOuter()->SetLocalOrigin(origin);
}

//-----------------------------------------------------------------------------

inline const Vector &CAI_Component::GetAbsOrigin() const {
    return GetOuter()->GetAbsOrigin();
}

//-----------------------------------------------------------------------------

inline const QAngle &CAI_Component::GetAbsAngles() const {
    return GetOuter()->GetAbsAngles();
}

//-----------------------------------------------------------------------------

inline void CAI_Component::SetSolid(SolidType_t val) {
    GetOuter()->SetSolid(val);
}

//-----------------------------------------------------------------------------

inline SolidType_t CAI_Component::GetSolid() const {
    return GetOuter()->GetSolid();
}

//-----------------------------------------------------------------------------

inline const Vector &CAI_Component::WorldAlignMins() const {
    return GetOuter()->WorldAlignMins();
}

//-----------------------------------------------------------------------------

inline const Vector &CAI_Component::WorldAlignMaxs() const {
    return GetOuter()->WorldAlignMaxs();
}

//-----------------------------------------------------------------------------

inline Hull_t CAI_Component::GetHullType() const {
    return GetOuter()->GetHullType();
}

//-----------------------------------------------------------------------------

inline Vector CAI_Component::WorldSpaceCenter() const {
    return GetOuter()->WorldSpaceCenter();
}

//-----------------------------------------------------------------------------

inline float CAI_Component::GetGravity() const {
    return GetOuter()->GetGravity();
}

//-----------------------------------------------------------------------------

inline void CAI_Component::SetGravity(float flGravity) {
    GetOuter()->SetGravity(flGravity);
}

//-----------------------------------------------------------------------------

inline float CAI_Component::GetHullWidth() const {
    return NAI_Hull::Width(GetOuter()->GetHullType());
}

//-----------------------------------------------------------------------------

inline float CAI_Component::GetHullHeight() const {
    return NAI_Hull::Height(GetOuter()->GetHullType());
}

//-----------------------------------------------------------------------------

inline const Vector &CAI_Component::GetHullMins() const {
    return NAI_Hull::Mins(GetOuter()->GetHullType());
}

//-----------------------------------------------------------------------------

inline const Vector &CAI_Component::GetHullMaxs() const {
    return NAI_Hull::Maxs(GetOuter()->GetHullType());
}

//-----------------------------------------------------------------------------

inline int CAI_Component::GetCollisionGroup() const {
    return GetOuter()->GetCollisionGroup();
}

//-----------------------------------------------------------------------------

inline CBaseEntity *CAI_Component::GetEnemy() { return GetOuter()->GetEnemy(); }

//-----------------------------------------------------------------------------

inline const Vector &CAI_Component::GetEnemyLKP() const {
    return GetOuter()->GetEnemyLKP();
}

//-----------------------------------------------------------------------------

inline void CAI_Component::TranslateNavGoal(CBaseEntity *pEnemy,
                                            Vector &chasePosition) {
    GetOuter()->TranslateNavGoal(pEnemy, chasePosition);
}

//-----------------------------------------------------------------------------

inline CBaseEntity *CAI_Component::GetTarget() {
    return GetOuter()->GetTarget();
}
//-----------------------------------------------------------------------------

inline void CAI_Component::SetTarget(CBaseEntity *pTarget) {
    GetOuter()->SetTarget(pTarget);
}

//-----------------------------------------------------------------------------

inline const Task_t *CAI_Component::GetCurTask() {
    return GetOuter()->GetTask();
}

//-----------------------------------------------------------------------------

inline void CAI_Component::TaskFail(AI_TaskFailureCode_t code) {
    GetOuter()->TaskFail(code);
}
//-----------------------------------------------------------------------------

inline void CAI_Component::TaskFail(const char *pszGeneralFailText) {
    GetOuter()->TaskFail(pszGeneralFailText);
}
//-----------------------------------------------------------------------------

inline void CAI_Component::TaskComplete(bool fIgnoreSetFailedCondition) {
    GetOuter()->TaskComplete(fIgnoreSetFailedCondition);
}
//-----------------------------------------------------------------------------

inline int CAI_Component::TaskIsRunning() {
    return GetOuter()->TaskIsRunning();
}
//-----------------------------------------------------------------------------

inline int CAI_Component::TaskIsComplete() {
    return GetOuter()->TaskIsComplete();
}

//-----------------------------------------------------------------------------

inline Activity CAI_Component::GetActivity() {
    return GetOuter()->GetActivity();
}
//-----------------------------------------------------------------------------

inline void CAI_Component::SetActivity(Activity NewActivity) {
    GetOuter()->SetActivity(NewActivity);
}
//-----------------------------------------------------------------------------

inline float CAI_Component::GetIdealSpeed() const {
    return GetOuter()->GetIdealSpeed();
}

//-----------------------------------------------------------------------------

inline float CAI_Component::GetIdealAccel() const {
    return GetOuter()->GetIdealAccel();
}

//-----------------------------------------------------------------------------

inline int CAI_Component::GetSequence() { return GetOuter()->GetSequence(); }

//-----------------------------------------------------------------------------

inline int CAI_Component::GetEntFlags() const { return GetOuter()->GetFlags(); }

//-----------------------------------------------------------------------------

inline void CAI_Component::AddEntFlag(int flags) { GetOuter()->AddFlag(flags); }

//-----------------------------------------------------------------------------

inline void CAI_Component::RemoveEntFlag(int flagsToRemove) {
    GetOuter()->RemoveFlag(flagsToRemove);
}

//-----------------------------------------------------------------------------
// Purpose: Change the ground entity for the outer
// Input  : *ground -
// Output : inline void
//-----------------------------------------------------------------------------
inline void CAI_Component::SetGroundEntity(CBaseEntity *ground) {
    GetOuter()->SetGroundEntity(ground);
}

//-----------------------------------------------------------------------------

inline void CAI_Component::ToggleEntFlag(int flagToToggle) {
    GetOuter()->ToggleFlag(flagToToggle);
}

//-----------------------------------------------------------------------------

inline CBaseEntity *CAI_Component::GetGoalEnt() {
    return GetOuter()->GetGoalEnt();
}
//-----------------------------------------------------------------------------

inline void CAI_Component::SetGoalEnt(CBaseEntity *pGoalEnt) {
    GetOuter()->SetGoalEnt(pGoalEnt);
}

//-----------------------------------------------------------------------------

inline void CAI_Component::Remember(int iMemory) {
    GetOuter()->Remember(iMemory);
}
//-----------------------------------------------------------------------------

inline void CAI_Component::Forget(int iMemory) { GetOuter()->Forget(iMemory); }
//-----------------------------------------------------------------------------

inline bool CAI_Component::HasMemory(int iMemory) {
    return GetOuter()->HasMemory(iMemory);
}

//-----------------------------------------------------------------------------

inline CAI_Enemies *CAI_Component::GetEnemies() {
    return GetOuter()->GetEnemies();
}

//-----------------------------------------------------------------------------

inline const char *CAI_Component::GetEntClassname() {
    return GetOuter()->GetClassname();
}

//-----------------------------------------------------------------------------

inline int CAI_Component::CapabilitiesGet() {
    return GetOuter()->CapabilitiesGet();
}

//-----------------------------------------------------------------------------

inline void CAI_Component::SetLocalAngles(const QAngle &angles) {
    GetOuter()->SetLocalAngles(angles);
}

//-----------------------------------------------------------------------------

inline const QAngle &CAI_Component::GetLocalAngles(void) const {
    return GetOuter()->GetLocalAngles();
}

//-----------------------------------------------------------------------------

inline edict_t *CAI_Component::GetEdict() {
    return GetOuter()->NetworkProp()->edict();
}

//-----------------------------------------------------------------------------

inline float CAI_Component::GetLastThink(const char *szContext) {
    return GetOuter()->GetLastThink(szContext);
}

// ============================================================================
abstract_class INPCInteractive {
   public:
    virtual bool CanInteractWith(CAI_BaseNPC * pUser) = 0;
    virtual bool HasBeenInteractedWith() = 0;
    virtual void NotifyInteraction(CAI_BaseNPC * pUser) = 0;

    // Alyx specific interactions
    virtual void AlyxStartedInteraction(void) = 0;
    virtual void AlyxFinishedInteraction(void) = 0;
};

// Base Class for any NPC that wants to be interactable by other NPCS (i.e. Alyx
// Hackable) NOTE: YOU MUST DEFINE THE OUTPUTS IN YOUR CLASS'S DATADESC!
//		 THE DO SO, INSERT THE FOLLOWING MACRO INTO YOUR CLASS'S
//DATADESC.
//
#define DEFINE_BASENPCINTERACTABLE_DATADESC()                              \
    DEFINE_OUTPUT(m_OnAlyxStartedInteraction, "OnAlyxStartedInteraction"), \
        DEFINE_OUTPUT(m_OnAlyxFinishedInteraction,                         \
                      "OnAlyxFinishedInteraction"),                        \
        DEFINE_INPUTFUNC(FIELD_VOID, "InteractivePowerDown", InputPowerdown)

template <class NPC_CLASS>
class CNPCBaseInteractive : public NPC_CLASS, public INPCInteractive {
    DECLARE_CLASS(CNPCBaseInteractive, NPC_CLASS);

   public:
    virtual bool CanInteractWith(CAI_BaseNPC *pUser) { return false; };
    virtual bool HasBeenInteractedWith() { return false; };
    virtual void NotifyInteraction(CAI_BaseNPC *pUser) { return; };

    virtual void InputPowerdown(inputdata_t &inputdata) {}

    // Alyx specific interactions
    virtual void AlyxStartedInteraction(void) {
        m_OnAlyxStartedInteraction.FireOutput(this, this);
    }
    virtual void AlyxFinishedInteraction(void) {
        m_OnAlyxFinishedInteraction.FireOutput(this, this);
    }

   public:
    // Outputs
    // Alyx specific interactions
    COutputEvent m_OnAlyxStartedInteraction;
    COutputEvent m_OnAlyxFinishedInteraction;
};

//
//	Deferred Navigation calls go here
//

extern ConVar ai_post_frame_navigation;

class CPostFrameNavigationHook : public CBaseGameSystemPerFrame {
   public:
    virtual const char *Name(void) { return "CPostFrameNavigationHook"; }

    virtual bool Init(void);
    virtual void FrameUpdatePostEntityThink(void);
    virtual void FrameUpdatePreEntityThink(void);

    bool IsGameFrameRunning(void) { return m_bGameFrameRunning; }
    void SetGrameFrameRunning(bool bState) { m_bGameFrameRunning = bState; }

    void EnqueueEntityNavigationQuery(CAI_BaseNPC *pNPC, CFunctor *functor);

   private:
    CUtlVector<CFunctor *> m_Functors;
    bool m_bGameFrameRunning;
};

extern CPostFrameNavigationHook *PostFrameNavigationSystem(void);

#endif  // AI_BASENPC_H