{

AIHCR_DEFAULT_AI,

AIHCR_MOVE_ON_COVER,

AIHCR_MOVE_IMMEDIATE,

{

AI_HintChangeReaction_t hintChangeReaction;

bool fCoverOnReload;

bool fPlayerIsBattleline;

float minTimeShots;

float maxTimeShots;

int minShots;

int maxShots;

int oddsCover;

bool fStayAtCover;

float flAbandonTimeLimit;

DECLARE_SIMPLE_DATADESC();

{

AIP_INDIFFERENT,

AIP_STANDING,

AIP_CROUCHING,

AIP_PEEKING,

{

DECLARE_CLASS( CAI_MappedActivityBehavior_Temporary, CAI_SimpleBehavior );

public:

CAI_MappedActivityBehavior_Temporary( CAI_BaseNPC *pOuter = NULL )

: CAI_SimpleBehavior(pOuter)

{

SetDefLessFunc( m_ActivityMap );

}

protected:

Activity GetMappedActivity( AI_Posture_t posture, Activity activity );

void OnChangeActiveWeapon( CBaseCombatWeapon *pOldWeapon, CBaseCombatWeapon *pNewWeapon );

virtual void UpdateTranslateActivityMap();

private:

CUtlMap<unsigned, Activity> m_ActivityMap;

{

DECLARE_CLASS( CAI_StandoffBehavior, CAI_MappedActivityBehavior_Temporary );

public:

CAI_StandoffBehavior( CAI_BaseNPC *pOuter = NULL );

virtual const char *GetName() { return "Standoff"; }

void SetActive( bool fActive );

void SetParameters( const AI_StandoffParams_t &params, CAI_GoalEntity *pGoalEntity = NULL );

Vector GetStandoffGoalPosition();

void SetStandoffGoalPosition( const Vector &vecPos );

void ClearStandoffGoalPosition();

AI_Posture_t GetPosture();

bool IsActive( void ) { return m_fActive; }

void OnChangeTacticalConstraints();

bool CanSelectSchedule();

bool IsBehindBattleLines( const Vector &point );

protected:

void Spawn();

void BeginScheduleSelection();

void EndScheduleSelection();

void PrescheduleThink();

void GatherConditions();

int SelectSchedule();

int TranslateSchedule( int scheduleType );

void StartTask( const Task_t *pTask );

void BuildScheduleTestBits();

virtual void OnUpdateShotRegulator();

Activity NPC_TranslateActivity( Activity eNewActivity );

bool IsValidCover( const Vector &vecCoverLocation, CAI_Hint const *pHint );

bool IsValidShootPosition( const Vector &vecCoverLocation, CAI_Node *pNode, CAI_Hint const *pHint );

void SetPosture( AI_Posture_t posture );

void OnChangeHintGroup( string_t oldGroup, string_t newGroup );

virtual int SelectScheduleUpdateWeapon();

virtual int SelectScheduleCheckCover();

virtual int SelectScheduleEstablishAim();

virtual int SelectScheduleAttack();

bool PlayerIsLeading();

CBaseEntity *GetPlayerLeader();

bool GetDirectionOfStandoff( Vector *pDir );

void UpdateBattleLines();

Hint_e GetHintType();

void SetReuseCurrentCover();

void UnlockHintNode();

Activity GetCoverActivity();

void OnRestore();

void UpdateTranslateActivityMap();

// Standoff overrides base AI crouch handling

bool IsCrouching( void ) { return false; }

private:

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

enum

{

NEXT_SCHEDULE = BaseClass::NEXT_SCHEDULE,

NEXT_TASK = BaseClass::NEXT_TASK,

COND_ABANDON_TIME_EXPIRED = BaseClass::NEXT_CONDITION,

NEXT_CONDITION

};

DEFINE_CUSTOM_SCHEDULE_PROVIDER;

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

// @TODO (toml 07-30-03): replace all these booleans with a singe 32 bit unsigned & bit flags

bool m_fActive;

bool m_fTestNoDamage;

Vector m_vecStandoffGoalPosition;

AI_Posture_t m_posture;

AI_StandoffParams_t m_params;

EHANDLE m_hStandoffGoal;

bool m_fTakeCover;

float m_SavedDistTooFar;

bool m_fForceNewEnemy;

CAI_MoveMonitor m_PlayerMoveMonitor;

CSimTimer m_TimeForceCoverHint;

CSimTimer m_TimePreventForceNewEnemy;

CRandSimTimer m_RandomCoverChangeTimer;

// FIXME: TEMPORARY! REMOVE

int m_nSavedMinShots, m_nSavedMaxShots;

float m_flSavedMinRest, m_flSavedMaxRest;

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

struct BattleLine_t

{

Vector point;

Vector normal;

};

CThinkOnceSemaphore m_UpdateBattleLinesSemaphore;

CUtlVector<BattleLine_t> m_BattleLines;

bool m_fIgnoreFronts;

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

bool m_bHasLowCoverActivity;

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

DECLARE_DATADESC();