hlsdk-portable/dlls/gearbox/fgrunt.cpp

/***
*
*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
*
*	This product contains software technology licensed from Id
*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc.
*	All Rights Reserved.
*
*   Use, distribution, and modification of this source code and/or resulting
*   object code is restricted to non-commercial enhancements to products from
*   Valve LLC.  All other use, distribution, or modification is prohibited
*   without written permission from Valve LLC.
*
****/
// Based on implementation by Raven City Team, modified by FreeSlave

#include	"extdll.h"
#include	"util.h"
#include	"cbase.h"
#include	"monsters.h"
#include	"animation.h"
#include	"talkmonster.h"
#include	"schedule.h"
#include	"defaultai.h"
#include	"scripted.h"
#include	"weapons.h"
#include	"soundent.h"
#include	"customentity.h"
#include	"decals.h"
#include	"hgrunt.h"

//=========================================================
//
//=========================================================
#define	FGRUNT_CLIP_SIZE				36 // how many bullets in a clip? - NOTE: 3 round burst sound, so keep as 3 * x!
#define FGRUNT_LIMP_HEALTH				20
#define FGRUNT_SENTENCE_VOLUME			0.35

#define FGRUNT_9MMAR					( 1 << 0)
#define FGRUNT_HANDGRENADE			( 1 << 1)
#define FGRUNT_GRENADELAUNCHER		( 1 << 2)
#define FGRUNT_SHOTGUN				( 1 << 3)
#define FGRUNT_M249					( 1 << 4)

// Torso group for weapons
#define	FG_TORSO_GROUP				2
#define FG_TORSO_DEFAULT			0
#define FG_TORSO_M249				1
#define FG_TORSO_FLAT				2
#define FG_TORSO_SHOTGUN			3

// Weapon group
#define FG_GUN_GROUP				3
#define FG_GUN_MP5					0
#define FG_GUN_SHOTGUN				1
#define FG_GUN_SAW					2
#define FG_GUN_NONE					3

#define CALL_MEDIC_DELAY				6 // Wait before calling for medic again.

//=========================================================
// monster-specific tasks
//=========================================================
enum
{
	TASK_HGRUNT_ALLY_FACE_TOSS_DIR = LAST_TALKMONSTER_TASK + 1,
	TASK_HGRUNT_ALLY_SPEAK_SENTENCE,
	TASK_HGRUNT_ALLY_CHECK_FIRE,
	TASK_HGRUNT_ALLY_FIND_MEDIC,
	LAST_HGRUNT_ALLY_TASK
};
//=========================================================
// monster heads
//=========================================================

// Head group
#define FG_HEAD_GROUP				1
enum
{
	FG_HEAD_MASK,
	FG_HEAD_BERET,
	FG_HEAD_SHOTGUN,
	FG_HEAD_SAW,
	FG_HEAD_SAW_BLACK,
	FG_HEAD_MP,
	FG_HEAD_MAJOR,
	FG_HEAD_BERET_BLACK,
	FG_HEAD_COUNT
};

//=========================================================
// Monster's Anim Events Go Here
//=========================================================
#define		HGRUNT_ALLY_AE_RELOAD		( 2 )
#define		HGRUNT_ALLY_AE_KICK			( 3 )
#define		HGRUNT_ALLY_AE_BURST1		( 4 )
#define		HGRUNT_ALLY_AE_BURST2		( 5 )
#define		HGRUNT_ALLY_AE_BURST3		( 6 )
#define		HGRUNT_ALLY_AE_GREN_TOSS	( 7 )
#define		HGRUNT_ALLY_AE_GREN_LAUNCH	( 8 )
#define		HGRUNT_ALLY_AE_GREN_DROP	( 9 )
#define		HGRUNT_ALLY_AE_CAUGHT_ENEMY	( 10) // grunt established sight with an enemy (player only) that had previously eluded the squad.
#define		HGRUNT_ALLY_AE_DROP_GUN		( 11) // grunt (probably dead) is dropping his mp5.
//=========================================================
// monster-specific schedule types
//=========================================================
enum
{
	SCHED_HGRUNT_ALLY_SUPPRESS = LAST_TALKMONSTER_SCHEDULE + 1,
	SCHED_HGRUNT_ALLY_ESTABLISH_LINE_OF_FIRE,// move to a location to set up an attack against the enemy. (usually when a friendly is in the way).
	SCHED_HGRUNT_ALLY_COVER_AND_RELOAD,
	SCHED_HGRUNT_ALLY_SWEEP,
	SCHED_HGRUNT_ALLY_FOUND_ENEMY,
	SCHED_HGRUNT_ALLY_REPEL,
	SCHED_HGRUNT_ALLY_REPEL_ATTACK,
	SCHED_HGRUNT_ALLY_REPEL_LAND,
	SCHED_HGRUNT_ALLY_WAIT_FACE_ENEMY,
	SCHED_HGRUNT_ALLY_TAKECOVER_FAILED,// special schedule type that forces analysis of conditions and picks the best possible schedule to recover from this type of failure.
	SCHED_HGRUNT_ALLY_ELOF_FAIL,
	SCHED_HGRUNT_ALLY_FIND_MEDIC,
	LAST_HGRUNT_ALLY_SCHEDULE,
};

enum
{
	SCHED_MEDIC_HEAL = LAST_HGRUNT_ALLY_SCHEDULE,
};

class CHFGrunt : public CTalkMonster
{
public:
	void Spawn( void );
	void Precache( void );
	void SetYawSpeed( void );
	int  ISoundMask( void );
	int  Classify ( void );
	void HandleAnimEvent( MonsterEvent_t *pEvent );
	void CheckAmmo ( void );
	void SetActivity ( Activity NewActivity );
	void RunTask( Task_t *pTask );
	void StartTask( Task_t *pTask );
	virtual int	ObjectCaps(void) { return CTalkMonster::ObjectCaps() | FCAP_IMPULSE_USE; }
	void KeyValue( KeyValueData *pkvd );
	BOOL FCanCheckAttacks ( void );
	BOOL CheckRangeAttack1 ( float flDot, float flDist );
	BOOL CheckRangeAttack2 ( float flDot, float flDist );
	BOOL CheckMeleeAttack1 ( float flDot, float flDist );

	void DeclineFollowing(void);
	int MaxFollowers() { return 5; }
	const char* FriendByNumber( int arrayNumber ) { return m_szFriends[FriendNumber(arrayNumber)]; }
	int NumberOfFriends() { return ARRAYSIZE(m_szFriends); }

	bool WantsToCallMedic();
	bool TryCallForMedic(CBaseEntity* pOther);

	void PrescheduleThink ( void );
	Vector GetGunPosition( void );
	void Shoot ( void );
	void Shotgun ( void );
	void M249 ( void );
	CBaseEntity	*Kick( void );
	// Override these to set behavior
	Schedule_t *GetScheduleOfType ( int Type );
	Schedule_t *GetSchedule ( void );
	Schedule_t *PrioritizedSchedule();
	MONSTERSTATE GetIdealState ( void );

	void AlertSound( void );
	void DeathSound( void );
	void PainSound( void );
	void IdleSound( void );

	void GibMonster( void );
	void SpeakSentence( void );
	void TalkInit( void );

	BOOL FOkToSpeak( void );
	void JustSpoke( void );

	void DropMyItems(BOOL isGibbed);
	void DropMyItem(const char *entityName, const Vector &vecGunPos, const Vector &vecGunAngles, BOOL isGibbed);

	void TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
	int TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
	int IRelationship ( CBaseEntity *pTarget );

	virtual int		Save( CSave &save );
	virtual int		Restore( CRestore &restore );
	static	TYPEDESCRIPTION m_SaveData[];

	// checking the feasibility of a grenade toss is kind of costly, so we do it every couple of seconds,
	// not every server frame.
	float m_flNextGrenadeCheck;
	float m_flNextPainTime;
	float m_flMedicWaitTime;

	bool	m_flLinkToggle;

	Vector	m_vecTossVelocity;

	BOOL	m_fThrowGrenade;
	BOOL	m_fStanding;
	BOOL	m_fFirstEncounter;// only put on the handsign show in the squad's first encounter.
	int		m_cClipSize;

	int		m_iSentence;
	int		m_iHead;

	float m_flLastHitByPlayer;
	int m_iPlayerHits;

	int		m_iBrassShell;
	int		m_iShotgunShell;
	int		m_iM249Shell;
	int		m_iM249Link;

	static const char *pGruntSentences[];

	static const char *m_szFriends[3];

	static int g_fGruntAllyQuestion;

	CUSTOM_SCHEDULES

protected:
	void KickImpl(float kickDamage);
	void PrecacheHelper();
	void SpawnHelper(const char* model, float health);
	const char* SentenceByNumber(int sentence) {
		return pGruntSentences[sentence];
	}
};

LINK_ENTITY_TO_CLASS( monster_human_grunt_ally, CHFGrunt )

int CHFGrunt::g_fGruntAllyQuestion = 0;

class CMedic : public CHFGrunt
{
public:
	void Spawn( void );
	void Precache( void );
	void HandleAnimEvent( MonsterEvent_t *pEvent );
	BOOL CheckRangeAttack1 ( float flDot, float flDist );
	BOOL CheckRangeAttack2 ( float flDot, float flDist );
	void GibMonster();

	void RunTask( Task_t *pTask );
	void StartTask( Task_t *pTask );
	Schedule_t *GetSchedule ( void );
	Schedule_t *GetScheduleOfType(int Type);
	void StopFollowing( BOOL clearSchedule );
	void SetAnswerQuestion(CTalkMonster *pSpeaker);

	void DropMyItems(BOOL isGibbed);

	void FirePistol ( const char* shotSound, Bullet bullet );
	bool Heal();
	void StartFollowingHealTarget(CBaseEntity* pTarget);
	bool ReadyToHeal();
	void StopHealing();
	CBaseEntity* HealTarget();
	inline bool HasHealTarget() { return HealTarget() != 0; }
	inline bool HasHealCharge() { return m_flHealCharge >= 1; }
	bool InHealSchedule();
	bool CheckHealCharge();

	virtual int Save( CSave &save );
	virtual int Restore( CRestore &restore );
	static	TYPEDESCRIPTION m_SaveData[];

	CUSTOM_SCHEDULES
	float m_flHealCharge;
	BOOL m_fDepleteLine;
	BOOL m_fHealing;
};

TYPEDESCRIPTION	CHFGrunt::m_SaveData[] =
{
	DEFINE_FIELD( CHFGrunt, m_flNextGrenadeCheck, FIELD_TIME ),
	DEFINE_FIELD( CHFGrunt, m_flNextPainTime, FIELD_TIME ),
	DEFINE_FIELD( CHFGrunt, m_vecTossVelocity, FIELD_VECTOR ),
	DEFINE_FIELD( CHFGrunt, m_fThrowGrenade, FIELD_BOOLEAN ),
	DEFINE_FIELD( CHFGrunt, m_fStanding, FIELD_BOOLEAN ),
	DEFINE_FIELD( CHFGrunt, m_fFirstEncounter, FIELD_BOOLEAN ),
	DEFINE_FIELD( CHFGrunt, m_cClipSize, FIELD_INTEGER ),
	DEFINE_FIELD( CHFGrunt, m_iHead, FIELD_INTEGER ),
	DEFINE_FIELD( CHFGrunt, m_flMedicWaitTime, FIELD_TIME ),
	DEFINE_FIELD( CHFGrunt, m_flLastHitByPlayer, FIELD_TIME ),
	DEFINE_FIELD( CHFGrunt, m_iPlayerHits, FIELD_INTEGER ),
};

IMPLEMENT_SAVERESTORE( CHFGrunt, CTalkMonster )

const char *CHFGrunt::m_szFriends[3] =
{
	"monster_human_grunt_ally",
	"monster_human_torch_ally",
	"monster_human_medic_ally",
};

const char *CHFGrunt::pGruntSentences[] =
{
	"FG_GREN", // grenade scared grunt
	"FG_ALERT", // sees player
	"FG_MONSTER", // sees monster
	"FG_COVER", // running to cover
	"FG_THROW", // about to throw grenade
	"FG_CHARGE",  // running out to get the enemy
	"FG_TAUNT", // say rude things
};

typedef enum
{
	FGRUNT_SENT_NONE = -1,
	FGRUNT_SENT_GREN = 0,
	FGRUNT_SENT_ALERT,
	FGRUNT_SENT_MONSTER,
	FGRUNT_SENT_COVER,
	FGRUNT_SENT_THROW,
	FGRUNT_SENT_CHARGE,
	FGRUNT_SENT_TAUNT,
} FGRUNT_SENTENCE_TYPES;

//=========================================================
// KeyValue
//
// !!! netname entvar field is used in squadmonster for groupname!!!
//=========================================================
void CHFGrunt :: KeyValue( KeyValueData *pkvd )
{
	if (FStrEq(pkvd->szKeyName, "head"))
	{
		m_iHead = atoi( pkvd->szValue );
		pkvd->fHandled = TRUE;
	}
	else
	{
		CTalkMonster::KeyValue( pkvd );
	}
}
//=========================================================
// someone else is talking - don't speak
//=========================================================
BOOL CHFGrunt :: FOkToSpeak( void )
{
// if someone else is talking, don't speak
	if (gpGlobals->time <= CTalkMonster::g_talkWaitTime)
		return FALSE;

	// if in the grip of a barnacle, don't speak
	if ( m_MonsterState == MONSTERSTATE_PRONE || m_IdealMonsterState == MONSTERSTATE_PRONE )
	{
		return FALSE;
	}

	// if not alive, certainly don't speak
	if ( pev->deadflag != DEAD_NO )
	{
		return FALSE;
	}

	if ( pev->spawnflags & SF_MONSTER_GAG )
	{
		if ( m_MonsterState != MONSTERSTATE_COMBAT )
		{
			// no talking outside of combat if gagged.
			return FALSE;
		}
	}

	return TRUE;
}
//=========================================================
//=========================================================
void CHFGrunt :: JustSpoke( void )
{
	CTalkMonster::g_talkWaitTime = gpGlobals->time + RANDOM_FLOAT(1.5, 2.0);
	m_iSentence = FGRUNT_SENT_NONE;
}
//=========================================================
// IRelationship - overridden because Male Assassins are
// Human Grunt's nemesis.
//=========================================================
int CHFGrunt::IRelationship ( CBaseEntity *pTarget )
{
	if ( FClassnameIs( pTarget->pev, "monster_male_assassin" ) )
	{
		return R_NM;
	}

	return CTalkMonster::IRelationship( pTarget );
}

//=========================================================
// AI Schedules Specific to this monster
//=========================================================

//=========================================================
// FGruntFail
//=========================================================
Task_t	tlFGruntFail[] =
{
	{ TASK_STOP_MOVING,			0				},
	{ TASK_SET_ACTIVITY,		(float)ACT_IDLE },
	{ TASK_WAIT,				(float)2		},
	{ TASK_WAIT_PVS,			(float)0		},
};

Schedule_t	slFGruntFail[] =
{
	{
		tlFGruntFail,
		ARRAYSIZE ( tlFGruntFail ),
		bits_COND_CAN_RANGE_ATTACK1 |
		bits_COND_CAN_RANGE_ATTACK2 |
		bits_COND_CAN_MELEE_ATTACK1 |
		bits_COND_CAN_MELEE_ATTACK2,
		0,
		"FGrunt Fail"
	},
};

//=========================================================
// FGrunt Combat Fail
//=========================================================
Task_t	tlFGruntCombatFail[] =
{
	{ TASK_STOP_MOVING,			0				},
	{ TASK_SET_ACTIVITY,		(float)ACT_IDLE },
	{ TASK_WAIT_FACE_ENEMY,		(float)2		},
	{ TASK_WAIT_PVS,			(float)0		},
};

Schedule_t	slFGruntCombatFail[] =
{
	{
		tlFGruntCombatFail,
		ARRAYSIZE ( tlFGruntCombatFail ),
		bits_COND_CAN_RANGE_ATTACK1	|
		bits_COND_CAN_RANGE_ATTACK2,
		0,
		"FGrunt Combat Fail"
	},
};

//=========================================================
// Victory dance!
//=========================================================
Task_t	tlFGruntVictoryDance[] =
{
	{ TASK_SET_FAIL_SCHEDULE,				(float)SCHED_FAIL			},
	{ TASK_STOP_MOVING,						(float)0					},
	{ TASK_FACE_ENEMY,						(float)0					},
	{ TASK_WAIT,							1.5f					},
	{ TASK_GET_PATH_TO_ENEMY_CORPSE,		64.0f					},
	{ TASK_WALK_PATH,						(float)0					},
	{ TASK_WAIT_FOR_MOVEMENT,				(float)0					},
	{ TASK_FACE_ENEMY,						(float)0					},
	{ TASK_PLAY_SEQUENCE,					(float)ACT_VICTORY_DANCE	},
};

Schedule_t	slFGruntVictoryDance[] =
{
	{
		tlFGruntVictoryDance,
		ARRAYSIZE ( tlFGruntVictoryDance ),
		bits_COND_NEW_ENEMY		|
		bits_COND_LIGHT_DAMAGE	|
		bits_COND_HEAVY_DAMAGE,
		0,
		"FGruntVictoryDance"
	},
};

//=========================================================
// Establish line of fire - move to a position that allows
// the grunt to attack.
//=========================================================
Task_t tlFGruntEstablishLineOfFire[] =
{
	{ TASK_SET_FAIL_SCHEDULE,	(float)SCHED_HGRUNT_ALLY_ELOF_FAIL	},
	{ TASK_GET_PATH_TO_ENEMY,	(float)0						},
	{ TASK_HGRUNT_ALLY_SPEAK_SENTENCE,(float)0						},
	{ TASK_RUN_PATH,			(float)0						},
	{ TASK_WAIT_FOR_MOVEMENT,	(float)0						},
};

Schedule_t slFGruntEstablishLineOfFire[] =
{
	{
		tlFGruntEstablishLineOfFire,
		ARRAYSIZE ( tlFGruntEstablishLineOfFire ),
		bits_COND_NEW_ENEMY			|
		bits_COND_ENEMY_DEAD		|
		bits_COND_CAN_RANGE_ATTACK1	|
		bits_COND_CAN_MELEE_ATTACK1	|
		bits_COND_CAN_RANGE_ATTACK2	|
		bits_COND_CAN_MELEE_ATTACK2	|
		bits_COND_HEAR_SOUND,

		bits_SOUND_DANGER,
		"FGruntEstablishLineOfFire"
	},
};

//=========================================================
// FGruntFoundEnemy - FGrunt established sight with an enemy
// that was hiding from the squad.
//=========================================================
Task_t	tlFGruntFoundEnemy[] =
{
	{ TASK_STOP_MOVING,				0							},
	{ TASK_FACE_ENEMY,				(float)0					},
	{ TASK_PLAY_SEQUENCE_FACE_ENEMY,(float)ACT_SIGNAL1			},
};

Schedule_t	slFGruntFoundEnemy[] =
{
	{
		tlFGruntFoundEnemy,
		ARRAYSIZE ( tlFGruntFoundEnemy ),
		bits_COND_HEAR_SOUND,

		bits_SOUND_DANGER,
		"FGruntFoundEnemy"
	},
};

//=========================================================
// GruntCombatFace Schedule
//=========================================================
Task_t	tlFGruntCombatFace1[] =
{
	{ TASK_STOP_MOVING,				0							},
	{ TASK_SET_ACTIVITY,			(float)ACT_IDLE				},
	{ TASK_FACE_ENEMY,				(float)0					},
	{ TASK_WAIT,					(float)1.5					},
	{ TASK_SET_SCHEDULE,			(float)SCHED_HGRUNT_ALLY_SWEEP	},
};

Schedule_t	slFGruntCombatFace[] =
{
	{
		tlFGruntCombatFace1,
		ARRAYSIZE ( tlFGruntCombatFace1 ),
		bits_COND_NEW_ENEMY				|
		bits_COND_ENEMY_DEAD			|
		bits_COND_CAN_RANGE_ATTACK1		|
		bits_COND_CAN_RANGE_ATTACK2,
		0,
		"Combat Face"
	},
};

//=========================================================
// Suppressing fire - don't stop shooting until the clip is
// empty or FGrunt gets hurt.
//=========================================================
Task_t	tlFGruntSignalSuppress[] =
{
	{ TASK_STOP_MOVING,						0						},
	{ TASK_FACE_IDEAL,						(float)0				},
	{ TASK_PLAY_SEQUENCE_FACE_ENEMY,		(float)ACT_SIGNAL2		},
	{ TASK_FACE_ENEMY,						(float)0				},
	{ TASK_HGRUNT_ALLY_CHECK_FIRE,			(float)0				},
	{ TASK_RANGE_ATTACK1,					(float)0				},
	{ TASK_FACE_ENEMY,						(float)0				},
	{ TASK_HGRUNT_ALLY_CHECK_FIRE,			(float)0				},
	{ TASK_RANGE_ATTACK1,					(float)0				},
	{ TASK_FACE_ENEMY,						(float)0				},
	{ TASK_HGRUNT_ALLY_CHECK_FIRE,			(float)0				},
	{ TASK_RANGE_ATTACK1,					(float)0				},
	{ TASK_FACE_ENEMY,						(float)0				},
	{ TASK_HGRUNT_ALLY_CHECK_FIRE,			(float)0				},
	{ TASK_RANGE_ATTACK1,					(float)0				},
	{ TASK_FACE_ENEMY,						(float)0				},
	{ TASK_HGRUNT_ALLY_CHECK_FIRE,			(float)0				},
	{ TASK_RANGE_ATTACK1,					(float)0				},
};

Schedule_t	slFGruntSignalSuppress[] =
{
	{
		tlFGruntSignalSuppress,
		ARRAYSIZE ( tlFGruntSignalSuppress ),
		bits_COND_ENEMY_DEAD		|
		bits_COND_LIGHT_DAMAGE		|
		bits_COND_HEAVY_DAMAGE		|
		bits_COND_HEAR_SOUND		|
		bits_COND_NOFIRE		|
		bits_COND_NO_AMMO_LOADED,

		bits_SOUND_DANGER,
		"SignalSuppress"
	},
};

Task_t	tlFGruntSuppress[] =
{
	{ TASK_STOP_MOVING,			0							},
	{ TASK_FACE_ENEMY,			(float)0					},
	{ TASK_HGRUNT_ALLY_CHECK_FIRE,	(float)0					},
	{ TASK_RANGE_ATTACK1,		(float)0					},
	{ TASK_FACE_ENEMY,			(float)0					},
	{ TASK_HGRUNT_ALLY_CHECK_FIRE,	(float)0					},
	{ TASK_RANGE_ATTACK1,		(float)0					},
	{ TASK_FACE_ENEMY,			(float)0					},
	{ TASK_HGRUNT_ALLY_CHECK_FIRE,	(float)0					},
	{ TASK_RANGE_ATTACK1,		(float)0					},
	{ TASK_FACE_ENEMY,			(float)0					},
	{ TASK_HGRUNT_ALLY_CHECK_FIRE,	(float)0					},
	{ TASK_RANGE_ATTACK1,		(float)0					},
	{ TASK_FACE_ENEMY,			(float)0					},
	{ TASK_HGRUNT_ALLY_CHECK_FIRE,	(float)0					},
	{ TASK_RANGE_ATTACK1,		(float)0					},
};

Schedule_t	slFGruntSuppress[] =
{
	{
		tlFGruntSuppress,
		ARRAYSIZE ( tlFGruntSuppress ),
		bits_COND_ENEMY_DEAD		|
		bits_COND_LIGHT_DAMAGE		|
		bits_COND_HEAVY_DAMAGE		|
		bits_COND_HEAR_SOUND		|
		bits_COND_NOFIRE		|
		bits_COND_NO_AMMO_LOADED,

		bits_SOUND_DANGER,
		"Suppress"
	},
};


//=========================================================
// FGrunt wait in cover - we don't allow danger or the ability
// to attack to break a grunt's run to cover schedule, but
// when a grunt is in cover, we do want them to attack if they can.
//=========================================================
Task_t	tlFGruntWaitInCover[] =
{
	{ TASK_STOP_MOVING,				(float)0					},
	{ TASK_SET_ACTIVITY,			(float)ACT_IDLE				},
	{ TASK_WAIT_FACE_ENEMY,			(float)1					},
};

Schedule_t	slFGruntWaitInCover[] =
{
	{
		tlFGruntWaitInCover,
		ARRAYSIZE ( tlFGruntWaitInCover ),
		bits_COND_NEW_ENEMY			|
		bits_COND_HEAR_SOUND		|
		bits_COND_CAN_RANGE_ATTACK1	|
		bits_COND_CAN_RANGE_ATTACK2	|
		bits_COND_CAN_MELEE_ATTACK1	|
		bits_COND_CAN_MELEE_ATTACK2,

		bits_SOUND_DANGER,
		"FGruntWaitInCover"
	},
};

//=========================================================
// run to cover.
// !!!BUGBUG - set a decent fail schedule here.
//=========================================================
Task_t	tlFGruntTakeCover1[] =
{
	{ TASK_STOP_MOVING,				(float)0							},
	{ TASK_SET_FAIL_SCHEDULE,		(float)SCHED_HGRUNT_ALLY_TAKECOVER_FAILED	},
	{ TASK_WAIT,					(float)0.2							},
	{ TASK_FIND_COVER_FROM_ENEMY,	(float)0							},
	{ TASK_HGRUNT_ALLY_SPEAK_SENTENCE,	(float)0								},
	{ TASK_RUN_PATH,				(float)0							},
	{ TASK_WAIT_FOR_MOVEMENT,		(float)0							},
	{ TASK_REMEMBER,				(float)bits_MEMORY_INCOVER			},
	{ TASK_SET_SCHEDULE,			(float)SCHED_HGRUNT_ALLY_WAIT_FACE_ENEMY	},
};

Schedule_t	slFGruntTakeCover[] =
{
	{
		tlFGruntTakeCover1,
		ARRAYSIZE ( tlFGruntTakeCover1 ),
		0,
		0,
		"TakeCover"
	},
};

//=========================================================
// drop grenade then run to cover.
//=========================================================
Task_t	tlFGruntGrenadeCover1[] =
{
	{ TASK_STOP_MOVING,						(float)0							},
	{ TASK_FIND_COVER_FROM_ENEMY,			(float)99							},
	{ TASK_FIND_FAR_NODE_COVER_FROM_ENEMY,	(float)384							},
	{ TASK_PLAY_SEQUENCE,					(float)ACT_SPECIAL_ATTACK1			},
	{ TASK_CLEAR_MOVE_WAIT,					(float)0							},
	{ TASK_RUN_PATH,						(float)0							},
	{ TASK_WAIT_FOR_MOVEMENT,				(float)0							},
	{ TASK_SET_SCHEDULE,					(float)SCHED_HGRUNT_ALLY_WAIT_FACE_ENEMY	},
};

Schedule_t	slFGruntGrenadeCover[] =
{
	{
		tlFGruntGrenadeCover1,
		ARRAYSIZE ( tlFGruntGrenadeCover1 ),
		0,
		0,
		"GrenadeCover"
	},
};


//=========================================================
// drop grenade then run to cover.
//=========================================================
Task_t	tlFGruntTossGrenadeCover1[] =
{
	{ TASK_FACE_ENEMY,						(float)0							},
	{ TASK_RANGE_ATTACK2, 					(float)0							},
	{ TASK_SET_SCHEDULE,					(float)SCHED_TAKE_COVER_FROM_ENEMY	},
};

Schedule_t	slFGruntTossGrenadeCover[] =
{
	{
		tlFGruntTossGrenadeCover1,
		ARRAYSIZE ( tlFGruntTossGrenadeCover1 ),
		0,
		0,
		"TossGrenadeCover"
	},
};

//=========================================================
// hide from the loudest sound source (to run from grenade)
//=========================================================
Task_t	tlFGruntTakeCoverFromBestSound[] =
{
	{ TASK_SET_FAIL_SCHEDULE,			(float)SCHED_COWER			},// duck and cover if cannot move from explosion
	{ TASK_STOP_MOVING,					(float)0					},
	{ TASK_FIND_COVER_FROM_BEST_SOUND,	(float)0					},
	{ TASK_RUN_PATH,					(float)0					},
	{ TASK_WAIT_FOR_MOVEMENT,			(float)0					},
	{ TASK_REMEMBER,					(float)bits_MEMORY_INCOVER	},
	{ TASK_TURN_LEFT,					(float)179					},
};

Schedule_t	slFGruntTakeCoverFromBestSound[] =
{
	{
		tlFGruntTakeCoverFromBestSound,
		ARRAYSIZE ( tlFGruntTakeCoverFromBestSound ),
		0,
		0,
		"FGruntTakeCoverFromBestSound"
	},
};

//=========================================================
// Grunt reload schedule
//=========================================================
Task_t	tlFGruntHideReload[] =
{
	{ TASK_SET_FAIL_SCHEDULE,		(float)SCHED_RELOAD			},
	{ TASK_STOP_MOVING,				(float)0					},
	{ TASK_FIND_COVER_FROM_ENEMY,	(float)0					},
	{ TASK_RUN_PATH,				(float)0					},
	{ TASK_WAIT_FOR_MOVEMENT,		(float)0					},
	{ TASK_REMEMBER,				(float)bits_MEMORY_INCOVER	},
	{ TASK_FACE_ENEMY,				(float)0					},
	{ TASK_PLAY_SEQUENCE,			(float)ACT_RELOAD			},
};

Schedule_t slFGruntHideReload[] =
{
	{
		tlFGruntHideReload,
		ARRAYSIZE ( tlFGruntHideReload ),
		bits_COND_HEAVY_DAMAGE	|
		bits_COND_ENEMY_DEAD	| // stop running away if enemy is already dead
		bits_COND_HEAR_SOUND,

		bits_SOUND_DANGER,
		"FGruntHideReload"
	}
};

//=========================================================
// Do a turning sweep of the area
//=========================================================
Task_t	tlFGruntSweep[] =
{
	{ TASK_TURN_LEFT,			(float)179	},
	{ TASK_WAIT,				(float)1	},
	{ TASK_TURN_LEFT,			(float)179	},
	{ TASK_WAIT,				(float)1	},
};

Schedule_t	slFGruntSweep[] =
{
	{
		tlFGruntSweep,
		ARRAYSIZE ( tlFGruntSweep ),

		bits_COND_NEW_ENEMY		|
		bits_COND_LIGHT_DAMAGE	|
		bits_COND_HEAVY_DAMAGE	|
		bits_COND_CAN_RANGE_ATTACK1	|
		bits_COND_CAN_RANGE_ATTACK2	|
		bits_COND_HEAR_SOUND,

		bits_SOUND_WORLD		|// sound flags
		bits_SOUND_DANGER		|
		bits_SOUND_PLAYER,

		"FGrunt Sweep"
	},
};

//=========================================================
// primary range attack. Overriden because base class stops attacking when the enemy is occluded.
// grunt's grenade toss requires the enemy be occluded.
//=========================================================
Task_t	tlFGruntRangeAttack1A[] =
{
	{ TASK_STOP_MOVING,			(float)0		},
	{ TASK_PLAY_SEQUENCE_FACE_ENEMY,		(float)ACT_CROUCH },
	{ TASK_HGRUNT_ALLY_CHECK_FIRE,	(float)0		},
	{ TASK_RANGE_ATTACK1,		(float)0		},
	{ TASK_FACE_ENEMY,			(float)0		},
	{ TASK_HGRUNT_ALLY_CHECK_FIRE,	(float)0		},
	{ TASK_RANGE_ATTACK1,		(float)0		},
	{ TASK_FACE_ENEMY,			(float)0		},
	{ TASK_HGRUNT_ALLY_CHECK_FIRE,	(float)0		},
	{ TASK_RANGE_ATTACK1,		(float)0		},
	{ TASK_FACE_ENEMY,			(float)0		},
	{ TASK_HGRUNT_ALLY_CHECK_FIRE,	(float)0		},
	{ TASK_RANGE_ATTACK1,		(float)0		},
};

Schedule_t	slFGruntRangeAttack1A[] =
{
	{
		tlFGruntRangeAttack1A,
		ARRAYSIZE ( tlFGruntRangeAttack1A ),
		bits_COND_NEW_ENEMY			|
		bits_COND_ENEMY_DEAD		|
		bits_COND_HEAVY_DAMAGE		|
		bits_COND_ENEMY_OCCLUDED	|
		bits_COND_HEAR_SOUND		|
		bits_COND_NOFIRE		|
		bits_COND_NO_AMMO_LOADED,

		bits_SOUND_DANGER,
		"Range Attack1A"
	},
};


//=========================================================
// primary range attack. Overriden because base class stops attacking when the enemy is occluded.
// grunt's grenade toss requires the enemy be occluded.
//=========================================================
Task_t	tlFGruntRangeAttack1B[] =
{
	{ TASK_STOP_MOVING,				(float)0		},
	{ TASK_PLAY_SEQUENCE_FACE_ENEMY,(float)ACT_IDLE_ANGRY  },
	{ TASK_HGRUNT_ALLY_CHECK_FIRE,	(float)0		},
	{ TASK_RANGE_ATTACK1,		(float)0		},
	{ TASK_FACE_ENEMY,			(float)0		},
	{ TASK_HGRUNT_ALLY_CHECK_FIRE,	(float)0		},
	{ TASK_RANGE_ATTACK1,		(float)0		},
	{ TASK_FACE_ENEMY,			(float)0		},
	{ TASK_HGRUNT_ALLY_CHECK_FIRE,	(float)0		},
	{ TASK_RANGE_ATTACK1,		(float)0		},
	{ TASK_FACE_ENEMY,			(float)0		},
	{ TASK_HGRUNT_ALLY_CHECK_FIRE,	(float)0		},
	{ TASK_RANGE_ATTACK1,		(float)0		},
};

Schedule_t	slFGruntRangeAttack1B[] =
{
	{
		tlFGruntRangeAttack1B,
		ARRAYSIZE ( tlFGruntRangeAttack1B ),
		bits_COND_NEW_ENEMY			|
		bits_COND_ENEMY_DEAD		|
		bits_COND_HEAVY_DAMAGE		|
		bits_COND_ENEMY_OCCLUDED	|
		bits_COND_NO_AMMO_LOADED	|
		bits_COND_NOFIRE		|
		bits_COND_HEAR_SOUND,

		bits_SOUND_DANGER,
		"Range Attack1B"
	},
};

//=========================================================
// secondary range attack. Overriden because base class stops attacking when the enemy is occluded.
// grunt's grenade toss requires the enemy be occluded.
//=========================================================
Task_t	tlFGruntRangeAttack2[] =
{
	{ TASK_STOP_MOVING,				(float)0					},
	{ TASK_HGRUNT_ALLY_FACE_TOSS_DIR,		(float)0					},
	{ TASK_PLAY_SEQUENCE,			(float)ACT_RANGE_ATTACK2	},
	{ TASK_SET_SCHEDULE,			(float)SCHED_HGRUNT_ALLY_WAIT_FACE_ENEMY	},// don't run immediately after throwing grenade.
};

Schedule_t	slFGruntRangeAttack2[] =
{
	{
		tlFGruntRangeAttack2,
		ARRAYSIZE ( tlFGruntRangeAttack2 ),
		0,
		0,
		"RangeAttack2"
	},
};


//=========================================================
// repel
//=========================================================
Task_t	tlFGruntRepel[] =
{
	{ TASK_STOP_MOVING,			(float)0		},
	{ TASK_FACE_IDEAL,			(float)0		},
	{ TASK_PLAY_SEQUENCE,		(float)ACT_GLIDE 	},
};

Schedule_t	slFGruntRepel[] =
{
	{
		tlFGruntRepel,
		ARRAYSIZE ( tlFGruntRepel ),
		bits_COND_SEE_ENEMY			|
		bits_COND_NEW_ENEMY			|
		bits_COND_LIGHT_DAMAGE		|
		bits_COND_HEAVY_DAMAGE		|
		bits_COND_HEAR_SOUND,

		bits_SOUND_DANGER			|
		bits_SOUND_COMBAT			|
		bits_SOUND_PLAYER,
		"Repel"
	},
};


//=========================================================
// repel
//=========================================================
Task_t	tlFGruntRepelAttack[] =
{
	{ TASK_STOP_MOVING,			(float)0		},
	{ TASK_FACE_ENEMY,			(float)0		},
	{ TASK_PLAY_SEQUENCE,		(float)ACT_FLY 	},
};

Schedule_t	slFGruntRepelAttack[] =
{
	{
		tlFGruntRepelAttack,
		ARRAYSIZE ( tlFGruntRepelAttack ),
		bits_COND_ENEMY_OCCLUDED,
		0,
		"Repel Attack"
	},
};

//=========================================================
// repel land
//=========================================================
Task_t	tlFGruntRepelLand[] =
{
	{ TASK_STOP_MOVING,			(float)0		},
	{ TASK_PLAY_SEQUENCE,		(float)ACT_LAND	},
	{ TASK_GET_PATH_TO_LASTPOSITION,(float)0				},
	{ TASK_RUN_PATH,				(float)0				},
	{ TASK_WAIT_FOR_MOVEMENT,		(float)0				},
	{ TASK_CLEAR_LASTPOSITION,		(float)0				},
};

Schedule_t	slFGruntRepelLand[] =
{
	{
		tlFGruntRepelLand,
		ARRAYSIZE ( tlFGruntRepelLand ),
		bits_COND_SEE_ENEMY			|
		bits_COND_NEW_ENEMY			|
		bits_COND_LIGHT_DAMAGE		|
		bits_COND_HEAVY_DAMAGE		|
		bits_COND_HEAR_SOUND,

		bits_SOUND_DANGER			|
		bits_SOUND_COMBAT			|
		bits_SOUND_PLAYER,
		"Repel Land"
	},
};

//=========================================================
// Find medic. Grunt stops moving and calls the nearest medic,
// if none is around, we don't do much. I don't think I have much
// to put in here, other than to make the grunt stop moving, and
// run the medic calling task, I guess.
//=========================================================
Task_t	tlGruntFindMedic[] =
{
	{ TASK_STOP_MOVING,		(float)0	},
	{ TASK_HGRUNT_ALLY_FIND_MEDIC,		(float)0	},
	{ TASK_WAIT,			(float)2	},
};

Schedule_t	slGruntFindMedic[] =
{
	{
		tlGruntFindMedic,
		ARRAYSIZE ( tlGruntFindMedic ),
		bits_COND_NEW_ENEMY			|
		bits_COND_SEE_FEAR			|
		bits_COND_LIGHT_DAMAGE		|
		bits_COND_HEAVY_DAMAGE		|
		bits_COND_HEAR_SOUND		|
		bits_COND_PROVOKED,
		bits_SOUND_DANGER,

		"Find Medic"
	},
};

Task_t tlGruntFaceTarget[] =
{
	{ TASK_SET_ACTIVITY, (float)ACT_IDLE },
	{ TASK_FACE_TARGET, (float)0 },
	{ TASK_SET_ACTIVITY, (float)ACT_IDLE },
	{ TASK_SET_SCHEDULE, (float)SCHED_TARGET_CHASE },
};

Schedule_t slGruntFaceTarget[] =
{
	{
		tlGruntFaceTarget,
		ARRAYSIZE( tlGruntFaceTarget ),
		bits_COND_CLIENT_PUSH |
		bits_COND_NEW_ENEMY |
		bits_COND_LIGHT_DAMAGE |
		bits_COND_HEAVY_DAMAGE |
		bits_COND_HEAR_SOUND |
		bits_COND_PROVOKED,
		bits_SOUND_DANGER,
		"FaceTarget"
	},
};

Task_t tlIdleGruntStand[] =
{
	{ TASK_STOP_MOVING, 0 },
	{ TASK_SET_ACTIVITY, (float)ACT_IDLE },
	{ TASK_WAIT, (float)2 }, // repick IDLESTAND every two seconds.
	{ TASK_TLK_HEADRESET, (float)0 }, // reset head position
};

Schedule_t slIdleGruntStand[] =
{
	{
		tlIdleGruntStand,
		ARRAYSIZE( tlIdleGruntStand ),
		bits_COND_NEW_ENEMY |
		bits_COND_LIGHT_DAMAGE |
		bits_COND_HEAVY_DAMAGE |
		bits_COND_HEAR_SOUND |
		bits_COND_SMELL |
		bits_COND_PROVOKED,
		bits_SOUND_COMBAT |// sound flags - change these, and you'll break the talking code.
		//bits_SOUND_PLAYER |
		//bits_SOUND_WORLD |
		bits_SOUND_DANGER |
		bits_SOUND_MEAT |// scents
		bits_SOUND_CARCASS |
		bits_SOUND_GARBAGE,
		"IdleStand"
	},
};

Task_t tlGruntFollow[] =
{
	{ TASK_MOVE_TO_TARGET_RANGE, (float)128 },	// Move within 128 of target ent (client)
	{ TASK_SET_SCHEDULE, (float)SCHED_TARGET_FACE },
};

Schedule_t slGruntFollow[] =
{
	{
		tlGruntFollow,
		ARRAYSIZE( tlGruntFollow ),
		bits_COND_NEW_ENEMY |
		bits_COND_LIGHT_DAMAGE |
		bits_COND_HEAVY_DAMAGE |
		bits_COND_HEAR_SOUND |
		bits_COND_PROVOKED,
		bits_SOUND_DANGER,
		"Follow"
	},
};

DEFINE_CUSTOM_SCHEDULES( CHFGrunt )
{
	slFGruntFail,
	slFGruntCombatFail,
	slFGruntVictoryDance,
	slFGruntEstablishLineOfFire,
	slFGruntFoundEnemy,
	slFGruntCombatFace,
	slFGruntSignalSuppress,
	slFGruntSuppress,
	slFGruntWaitInCover,
	slFGruntTakeCover,
	slFGruntGrenadeCover,
	slFGruntTossGrenadeCover,
	slFGruntTakeCoverFromBestSound,
	slFGruntHideReload,
	slFGruntSweep,
	slFGruntRangeAttack1A,
	slFGruntRangeAttack1B,
	slFGruntRangeAttack2,
	slFGruntRepel,
	slFGruntRepelAttack,
	slFGruntRepelLand,
	slGruntFindMedic,
	slGruntFaceTarget,
	slIdleGruntStand,
	slGruntFollow,
};


IMPLEMENT_CUSTOM_SCHEDULES( CHFGrunt, CTalkMonster )

void CHFGrunt :: StartTask( Task_t *pTask )
{
	m_iTaskStatus = TASKSTATUS_RUNNING;

	switch ( pTask->iTask )
	{
	case TASK_HGRUNT_ALLY_CHECK_FIRE:
		if( !NoFriendlyFire() )
		{
			SetConditions( bits_COND_NOFIRE );
		}
		TaskComplete();
		break;
	case TASK_HGRUNT_ALLY_SPEAK_SENTENCE:
		SpeakSentence();
		TaskComplete();
		break;

	case TASK_WALK_PATH:
	case TASK_RUN_PATH:
		// grunt no longer assumes he is covered if he moves
		Forget( bits_MEMORY_INCOVER );
		CTalkMonster ::StartTask( pTask );
		break;

	case TASK_RELOAD:
		m_IdealActivity = ACT_RELOAD;
		break;

	case TASK_HGRUNT_ALLY_FACE_TOSS_DIR:
		break;

	case TASK_FACE_IDEAL:
	case TASK_FACE_ENEMY:
		CTalkMonster :: StartTask( pTask );
		if (pev->movetype == MOVETYPE_FLY)
		{
			m_IdealActivity = ACT_GLIDE;
		}
		break;
	case TASK_HGRUNT_ALLY_FIND_MEDIC:
		{
			// First try looking for a medic in my squad
			if ( InSquad() )
			{
				CSquadMonster *pSquadLeader = MySquadLeader( );
				if ( pSquadLeader )
				{
					for (int i = 0; i < MAX_SQUAD_MEMBERS; i++)
					{
						CSquadMonster *pMember = pSquadLeader->MySquadMember(i);
						if (pMember != 0 && FClassnameIs(pMember->pev, "monster_human_medic_ally") && TryCallForMedic(pMember))
						{
							TaskComplete();
							break;
						}
					}
				}
			}
			// If not, search bsp.
			if ( !TaskIsComplete() )
			{
				// for each medic in this bsp...
				CBaseEntity *pFriend = NULL;
				TraceResult tr;
				Vector vecCheck;

				while( ( pFriend = UTIL_FindEntityByClassname( pFriend, "monster_human_medic_ally" ) ) )
				{
					if( pFriend == this || !pFriend->IsAlive() )
						// don't talk to self or dead people
						continue;
					vecCheck = pFriend->pev->origin;
					vecCheck.z = pFriend->pev->absmax.z;

					UTIL_TraceLine( pev->origin, vecCheck, ignore_monsters, ENT( pev ), &tr );

					if( tr.flFraction == 1.0 )
					{
						if (TryCallForMedic(pFriend))
						{
							TaskComplete();
							break;
						}
					}
				}
			}
			if ( !TaskIsComplete() )
			{
				TaskFail();
			}
			m_flMedicWaitTime = CALL_MEDIC_DELAY + gpGlobals->time;
		}
		break;
	default:
		CTalkMonster :: StartTask( pTask );
		break;
	}
}

void CHFGrunt :: RunTask( Task_t *pTask )
{
	switch ( pTask->iTask )
	{

	case TASK_HGRUNT_ALLY_FACE_TOSS_DIR:
		{
			// project a point along the toss vector and turn to face that point.
			MakeIdealYaw( pev->origin + m_vecTossVelocity * 64 );
			ChangeYaw( pev->yaw_speed );

			if ( FacingIdeal() )
			{
				m_iTaskStatus = TASKSTATUS_COMPLETE;
			}
			break;
		}
	default:
		{
			CTalkMonster :: RunTask( pTask );
			break;
		}
	}
}
//=========================================================
// GibMonster - make gun fly through the air.
//=========================================================
void CHFGrunt :: GibMonster ( void )
{
	Vector	vecGunPos;
	Vector	vecGunAngles;

	if ( GetBodygroup( FG_GUN_GROUP ) != FG_GUN_NONE )
	{// throw a gun if the grunt has one
		DropMyItems(TRUE);
	}

	CTalkMonster::GibMonster();
}

void CHFGrunt::DropMyItem(const char* entityName, const Vector& vecGunPos, const Vector& vecGunAngles, BOOL isGibbed)
{
	CBaseEntity* pGun = DropItem(entityName, vecGunPos, vecGunAngles);
	if (pGun && isGibbed) {
		pGun->pev->velocity = Vector( RANDOM_FLOAT( -100, 100 ), RANDOM_FLOAT( -100, 100 ), RANDOM_FLOAT( 200, 300 ) );
		pGun->pev->avelocity = Vector( 0, RANDOM_FLOAT( 200, 400 ), 0 );
	}
}

void CHFGrunt::DropMyItems(BOOL isGibbed)
{
	Vector vecGunPos;
	Vector vecGunAngles;
	GetAttachment( 0, vecGunPos, vecGunAngles );

	if (!isGibbed) {
		SetBodygroup( FG_GUN_GROUP, FG_GUN_NONE );
	}
	if (FBitSet( pev->weapons, FGRUNT_SHOTGUN ))
	{
		DropMyItem( "weapon_shotgun", vecGunPos, vecGunAngles, isGibbed );
	}
	else if (FBitSet( pev->weapons, FGRUNT_9MMAR ))
	{
		DropMyItem( "weapon_9mmAR", vecGunPos, vecGunAngles, isGibbed );
	}
	else if (FBitSet( pev->weapons, FGRUNT_M249 ))
	{
		DropMyItem( "weapon_m249", vecGunPos, vecGunAngles, isGibbed );
	}

	if (FBitSet( pev->weapons, FGRUNT_GRENADELAUNCHER ))
	{
		DropMyItem( "ammo_ARgrenades", isGibbed ? vecGunPos : BodyTarget( pev->origin ), vecGunAngles, isGibbed );
	}
	pev->weapons = 0;
}

void CHFGrunt::SpeakSentence( void )
{
	if( m_iSentence == FGRUNT_SENT_NONE )
	{
		// no sentence cued up.
		return;
	}

	if( FOkToSpeak() )
	{
		SENTENCEG_PlayRndSz( ENT( pev ), SentenceByNumber(m_iSentence), FGRUNT_SENTENCE_VOLUME, ATTN_NORM, 0, m_voicePitch );
		JustSpoke();
	}
}

//=========================================================
// ISoundMask - returns a bit mask indicating which types
// of sounds this monster regards.
//=========================================================
int CHFGrunt :: ISoundMask ( void)
{
	return	bits_SOUND_WORLD	|
			bits_SOUND_COMBAT	|
			bits_SOUND_CARCASS	|
			bits_SOUND_MEAT		|
			bits_SOUND_GARBAGE	|
			bits_SOUND_DANGER	|
			bits_SOUND_PLAYER;
}
//=========================================================
// CheckAmmo - overridden for the grunt because he actually
// uses ammo! (base class doesn't)
//=========================================================
void CHFGrunt :: CheckAmmo ( void )
{
	if ( m_cAmmoLoaded <= 0 )
	{
		SetConditions(bits_COND_NO_AMMO_LOADED);
	}
}
//=========================================================
// Classify - indicates this monster's place in the
// relationship table.
//=========================================================
int	CHFGrunt :: Classify ( void )
{
	return CLASS_PLAYER_ALLY_MILITARY;
}
//=========================================================
// SetYawSpeed - allows each sequence to have a different
// turn rate associated with it.
//=========================================================
void CHFGrunt :: SetYawSpeed ( void )
{
	int ys;

	switch ( m_Activity )
	{
	case ACT_IDLE:
		ys = 150;
		break;
	case ACT_RUN:
		ys = 150;
		break;
	case ACT_WALK:
		ys = 180;
		break;
	case ACT_RANGE_ATTACK1:
		ys = 120;
		break;
	case ACT_RANGE_ATTACK2:
		ys = 120;
		break;
	case ACT_MELEE_ATTACK1:
		ys = 120;
		break;
	case ACT_MELEE_ATTACK2:
		ys = 120;
		break;
	case ACT_TURN_LEFT:
	case ACT_TURN_RIGHT:
		ys = 180;
		break;
	case ACT_GLIDE:
	case ACT_FLY:
		ys = 30;
		break;
	default:
		ys = 90;
		break;
	}

	pev->yaw_speed = ys;
}


//=========================================================
// PrescheduleThink - this function runs after conditions
// are collected and before scheduling code is run.
//=========================================================
void CHFGrunt :: PrescheduleThink ( void )
{
	if ( InSquad() && m_hEnemy != 0 )
	{
		if ( HasConditions ( bits_COND_SEE_ENEMY ) )
		{
			// update the squad's last enemy sighting time.
			MySquadLeader()->m_flLastEnemySightTime = gpGlobals->time;
		}
		else
		{
			if ( gpGlobals->time - MySquadLeader()->m_flLastEnemySightTime > 5 )
			{
				// been a while since we've seen the enemy
				MySquadLeader()->m_fEnemyEluded = TRUE;
			}
		}
	}
	CTalkMonster::PrescheduleThink();
}

bool CHFGrunt::WantsToCallMedic()
{
	return pev->health <= pev->max_health * 0.5 && ( m_flMedicWaitTime < gpGlobals->time );
}

bool CHFGrunt::TryCallForMedic(CBaseEntity* pOther)
{
	if ( pOther && pOther != this && pOther->pev->deadflag == DEAD_NO )
	{
		CMedic* medic = (CMedic*)pOther->MySquadMonsterPointer();

		if ( medic != 0 && medic->ReadyToHeal() )
		{
			EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "fgrunt/medic.wav", 1, ATTN_NORM, 0, GetVoicePitch());
			ALERT( at_aiconsole, "Injured %s called for %s\n", STRING(pev->classname), STRING(medic->pev->classname) );
			medic->StartFollowingHealTarget(this);
			return true;
		}
	}
	return false;
}

//=========================================================
// FCanCheckAttacks - this is overridden for human grunts
// because they can throw/shoot grenades when they can't see their
// target and the base class doesn't check attacks if the monster
// cannot see its enemy.
//
// !!!BUGBUG - this gets called before a 3-round burst is fired
// which means that a friendly can still be hit with up to 2 rounds.
// ALSO, grenades will not be tossed if there is a friendly in front,
// this is a bad bug. Friendly machine gun fire avoidance
// will unecessarily prevent the throwing of a grenade as well.
//=========================================================
BOOL CHFGrunt :: FCanCheckAttacks ( void )
{
	if ( !HasConditions( bits_COND_ENEMY_TOOFAR ) )
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}


//=========================================================
// CheckMeleeAttack1
//=========================================================
BOOL CHFGrunt :: CheckMeleeAttack1 ( float flDot, float flDist )
{
	CBaseMonster *pEnemy;

	if ( m_hEnemy != 0 )
	{
		pEnemy = m_hEnemy->MyMonsterPointer();

		if ( !pEnemy )
		{
			return FALSE;
		}
	}

	if ( flDist <= 64 && flDot >= 0.7	&&
		 pEnemy->Classify() != CLASS_ALIEN_BIOWEAPON &&
		 pEnemy->Classify() != CLASS_PLAYER_BIOWEAPON )
	{
		return TRUE;
	}
	return FALSE;
}

//=========================================================
// CheckRangeAttack1 - overridden for HGrunt, cause
// FCanCheckAttacks() doesn't disqualify all attacks based
// on whether or not the enemy is occluded because unlike
// the base class, the HGrunt can attack when the enemy is
// occluded (throw grenade over wall, etc). We must
// disqualify the machine gun attack if the enemy is occluded.
//=========================================================
BOOL CHFGrunt :: CheckRangeAttack1 ( float flDot, float flDist )
{
	if ( !HasConditions( bits_COND_ENEMY_OCCLUDED ) && flDist <= 2048 && flDot >= 0.5 && NoFriendlyFire() && ( GetBodygroup( 3 ) != 3 ) )
	{
		TraceResult	tr;

		if ( !m_hEnemy->IsPlayer() && flDist <= 64 )
		{
			// kick nonclients, but don't shoot at them.
			return FALSE;
		}

		Vector vecSrc = GetGunPosition();

		// verify that a bullet fired from the gun will hit the enemy before the world.
		UTIL_TraceLine( vecSrc, m_hEnemy->BodyTarget(vecSrc), ignore_monsters, ignore_glass, ENT(pev), &tr);

		if ( tr.flFraction == 1.0 )
		{
			return TRUE;
		}
	}

	return FALSE;
}

//=========================================================
// CheckRangeAttack2 - this checks the Grunt's grenade
// attack.
//=========================================================
BOOL CHFGrunt :: CheckRangeAttack2 ( float flDot, float flDist )
{
	if (! FBitSet(pev->weapons, (FGRUNT_HANDGRENADE | FGRUNT_GRENADELAUNCHER)) )
	{
		return FALSE;
	}

	// if the grunt isn't moving, it's ok to check.
	if ( m_flGroundSpeed != 0 )
	{
		m_fThrowGrenade = FALSE;
		return m_fThrowGrenade;
	}

	// assume things haven't changed too much since last time
	if (gpGlobals->time < m_flNextGrenadeCheck )
	{
		return m_fThrowGrenade;
	}

	if ( !FBitSet ( m_hEnemy->pev->flags, FL_ONGROUND ) && m_hEnemy->pev->waterlevel == 0 && m_vecEnemyLKP.z > pev->absmax.z  )
	{
		//!!!BUGBUG - we should make this check movetype and make sure it isn't FLY? Players who jump a lot are unlikely to
		// be grenaded.
		// don't throw grenades at anything that isn't on the ground!
		m_fThrowGrenade = FALSE;
		return m_fThrowGrenade;
	}

	Vector vecTarget;

	if (FBitSet( pev->weapons, FGRUNT_HANDGRENADE))
	{
		// find feet
		if (RANDOM_LONG(0,1))
		{
			// magically know where they are
			vecTarget = Vector( m_hEnemy->pev->origin.x, m_hEnemy->pev->origin.y, m_hEnemy->pev->absmin.z );
		}
		else
		{
			// toss it to where you last saw them
			vecTarget = m_vecEnemyLKP;
		}
		// vecTarget = m_vecEnemyLKP + (m_hEnemy->BodyTarget( pev->origin ) - m_hEnemy->pev->origin);
		// estimate position
		// vecTarget = vecTarget + m_hEnemy->pev->velocity * 2;
	}
	else
	{
		// find target
		// vecTarget = m_hEnemy->BodyTarget( pev->origin );
		vecTarget = m_vecEnemyLKP + (m_hEnemy->BodyTarget( pev->origin ) - m_hEnemy->pev->origin);
		// estimate position
		if (HasConditions( bits_COND_SEE_ENEMY))
			vecTarget = vecTarget + ((vecTarget - pev->origin).Length() / gSkillData.fgruntGrenadeSpeed) * m_hEnemy->pev->velocity;
	}

	// are any of my allies near the intended grenade impact area?
	if (SquadMemberInRange( vecTarget, 256 ))
	{
		// crap, I might blow my own guy up. Don't throw a grenade and don't check again for a while.
		m_flNextGrenadeCheck = gpGlobals->time + 1; // one full second.
		m_fThrowGrenade = FALSE;
		return m_fThrowGrenade;	//AJH need this or it is overridden later.
	}

	if ( ( vecTarget - pev->origin ).Length2D() <= 256 )
	{
		// crap, I don't want to blow myself up
		m_flNextGrenadeCheck = gpGlobals->time + 1; // one full second.
		m_fThrowGrenade = FALSE;
		return m_fThrowGrenade;
	}


	if (FBitSet( pev->weapons, FGRUNT_HANDGRENADE))
	{
		Vector vecToss = VecCheckToss( pev, GetGunPosition(), vecTarget, 0.5 );

		if ( vecToss != g_vecZero )
		{
			m_vecTossVelocity = vecToss;

			// throw a hand grenade
			m_fThrowGrenade = TRUE;
			// don't check again for a while.
			m_flNextGrenadeCheck = gpGlobals->time; // 1/3 second.
		}
		else
		{
			// don't throw
			m_fThrowGrenade = FALSE;
			// don't check again for a while.
			m_flNextGrenadeCheck = gpGlobals->time + 1; // one full second.
		}
	}
	else
	{
		Vector vecToss = VecCheckThrow( pev, GetGunPosition(), vecTarget, gSkillData.fgruntGrenadeSpeed, 0.5 );

		if ( vecToss != g_vecZero )
		{
			m_vecTossVelocity = vecToss;

			// throw a hand grenade
			m_fThrowGrenade = TRUE;
			// don't check again for a while.
			m_flNextGrenadeCheck = gpGlobals->time + 0.3; // 1/3 second.
		}
		else
		{
			// don't throw
			m_fThrowGrenade = FALSE;
			// don't check again for a while.
			m_flNextGrenadeCheck = gpGlobals->time + 1; // one full second.
		}
	}



	return m_fThrowGrenade;
}
//=========================================================
//=========================================================
CBaseEntity *CHFGrunt :: Kick( void )
{
	TraceResult tr;

	UTIL_MakeVectors( pev->angles );
	Vector vecStart = pev->origin;
	vecStart.z += pev->size.z * 0.5;
	Vector vecEnd = vecStart + (gpGlobals->v_forward * 70);

	UTIL_TraceHull( vecStart, vecEnd, dont_ignore_monsters, head_hull, ENT(pev), &tr );

	if ( tr.pHit )
	{
		CBaseEntity *pEntity = CBaseEntity::Instance( tr.pHit );
		if (pEntity && IRelationship(pEntity) != R_AL)
			return pEntity;
	}

	return NULL;
}

void CHFGrunt::KickImpl(float kickDamage)
{
	CBaseEntity *pHurt = Kick();

	if ( pHurt )
	{
		// SOUND HERE!
		UTIL_MakeVectors( pev->angles );
		pHurt->pev->punchangle.x = 15;
		pHurt->pev->velocity = pHurt->pev->velocity + gpGlobals->v_forward * 100 + gpGlobals->v_up * 50;
		pHurt->TakeDamage( pev, pev, kickDamage, DMG_CLUB );
	}
}

//=========================================================
// GetGunPosition	return the end of the barrel
//=========================================================

Vector CHFGrunt :: GetGunPosition( )
{
	if (m_fStanding )
	{
		return pev->origin + Vector( 0, 0, 60 );
	}
	else
	{
		return pev->origin + Vector( 0, 0, 48 );
	}
}

//=========================================================
// Shoot
//=========================================================
void CHFGrunt :: Shoot ( void )
{
	if (m_hEnemy == 0 )
	{
		return;
	}

	Vector vecShootOrigin = GetGunPosition();
	Vector vecShootDir = ShootAtEnemy( vecShootOrigin );

	UTIL_MakeVectors ( pev->angles );

	Vector	vecShellVelocity = gpGlobals->v_right * RANDOM_FLOAT(40,90) + gpGlobals->v_up * RANDOM_FLOAT(75,200) + gpGlobals->v_forward * RANDOM_FLOAT(-40, 40);
	EjectBrass ( vecShootOrigin - vecShootDir * 24, vecShellVelocity, pev->angles.y, m_iBrassShell, TE_BOUNCE_SHELL);
	FireBullets(1, vecShootOrigin, vecShootDir, VECTOR_CONE_4DEGREES, 2048, BULLET_MONSTER_MP5 ); // shoot +-5 degrees

	pev->effects |= EF_MUZZLEFLASH;

	//WeaponFlash ( vecShootOrigin );

	m_cAmmoLoaded--;// take away a bullet!

	Vector angDir = UTIL_VecToAngles( vecShootDir );
	SetBlending( 0, angDir.x );
}

//=========================================================
// Shoot
//=========================================================
void CHFGrunt :: Shotgun ( void )
{
	if (m_hEnemy == 0)
	{
		return;
	}

	Vector vecShootOrigin = GetGunPosition();
	Vector vecShootDir = ShootAtEnemy( vecShootOrigin );

	UTIL_MakeVectors ( pev->angles );

	Vector	vecShellVelocity = gpGlobals->v_right * RANDOM_FLOAT(40,90) + gpGlobals->v_up * RANDOM_FLOAT(75,200) + gpGlobals->v_forward * RANDOM_FLOAT(-40, 40);
	EjectBrass ( vecShootOrigin - vecShootDir * 24, vecShellVelocity, pev->angles.y, m_iShotgunShell, TE_BOUNCE_SHOTSHELL);
	FireBullets(gSkillData.fgruntShotgunPellets, vecShootOrigin, vecShootDir, VECTOR_CONE_9DEGREES, 2048, BULLET_PLAYER_BUCKSHOT, 0 ); // shoot +-7.5 degrees

	pev->effects |= EF_MUZZLEFLASH;

	//WeaponFlash ( vecShootOrigin );

	m_cAmmoLoaded--;// take away a bullet!

	Vector angDir = UTIL_VecToAngles( vecShootDir );
	SetBlending( 0, angDir.x );
}
//=========================================================
// Shoot
//=========================================================
void CHFGrunt :: M249 ( void )
{
	if (m_hEnemy == 0 )
	{
		return;
	}

	switch ( RANDOM_LONG(0,2) )
	{
		case 0: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "weapons/saw_fire1.wav", 1, ATTN_NORM ); break;
		case 1: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "weapons/saw_fire2.wav", 1, ATTN_NORM ); break;
		case 2: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "weapons/saw_fire3.wav", 1, ATTN_NORM ); break;
	}

	Vector vecShootOrigin = GetGunPosition();
	Vector vecShootDir = ShootAtEnemy( vecShootOrigin );

	UTIL_MakeVectors ( pev->angles );

	Vector	vecShellVelocity = gpGlobals->v_right * RANDOM_FLOAT(40,90) + gpGlobals->v_up * RANDOM_FLOAT(75,200) + gpGlobals->v_forward * RANDOM_FLOAT(-40, 40);

	m_flLinkToggle = !m_flLinkToggle;

	if (!m_flLinkToggle)
		EjectBrass ( vecShootOrigin - vecShootDir * 24, vecShellVelocity, pev->angles.y, m_iM249Shell, TE_BOUNCE_SHELL);
	else
		EjectBrass ( vecShootOrigin - vecShootDir * 24, vecShellVelocity, pev->angles.y, m_iM249Link, TE_BOUNCE_SHELL);

	FireBullets(1, vecShootOrigin, vecShootDir, VECTOR_CONE_6DEGREES, 2048, BULLET_MONSTER_556 ); // shoot +-5 degrees

	pev->effects |= EF_MUZZLEFLASH;

	//WeaponFlash ( vecShootOrigin );

	m_cAmmoLoaded--;// take away a bullet!

	Vector angDir = UTIL_VecToAngles( vecShootDir );
	SetBlending( 0, angDir.x );
}
//=========================================================
// HandleAnimEvent - catches the monster-specific messages
// that occur when tagged animation frames are played.
//=========================================================
void CHFGrunt :: HandleAnimEvent( MonsterEvent_t *pEvent )
{
	Vector	vecShootDir;
	Vector	vecShootOrigin;

	switch( pEvent->event )
	{
		case HGRUNT_ALLY_AE_DROP_GUN:
		{
			DropMyItems(FALSE);
			SetUse( NULL );
		}
		break;

		case HGRUNT_ALLY_AE_RELOAD:
			if (FBitSet( pev->weapons, FGRUNT_9MMAR | FGRUNT_SHOTGUN ))
			{
				EMIT_SOUND( ENT(pev), CHAN_WEAPON, "hgrunt/gr_reload1.wav", 1, ATTN_NORM );
			}
			else if (FBitSet( pev->weapons, FGRUNT_M249 ))
			{
				EMIT_SOUND( ENT(pev), CHAN_WEAPON, "weapons/saw_reload2.wav", 1, ATTN_NORM );
			}
			m_cAmmoLoaded = m_cClipSize;
			ClearConditions(bits_COND_NO_AMMO_LOADED);
			break;

		case HGRUNT_ALLY_AE_GREN_TOSS:
		{
			UTIL_MakeVectors( pev->angles );
			// CGrenade::ShootTimed( pev, pev->origin + gpGlobals->v_forward * 34 + Vector (0, 0, 32), m_vecTossVelocity, 3.5 );
			CGrenade::ShootTimed( pev, GetGunPosition(), m_vecTossVelocity, 3.5 );

			m_fThrowGrenade = FALSE;
			m_flNextGrenadeCheck = gpGlobals->time + 6;// wait six seconds before even looking again to see if a grenade can be thrown.
			// !!!LATER - when in a group, only try to throw grenade if ordered.
		}
		break;

		case HGRUNT_ALLY_AE_GREN_LAUNCH:
		{
			EMIT_SOUND(ENT(pev), CHAN_WEAPON, "weapons/glauncher.wav", 0.8, ATTN_NORM);
			CGrenade::ShootContact( pev, GetGunPosition(), m_vecTossVelocity );
			m_fThrowGrenade = FALSE;
			if (g_iSkillLevel == SKILL_EASY)
				m_flNextGrenadeCheck = gpGlobals->time + RANDOM_FLOAT( 2, 5 );// wait a random amount of time before shooting again
			else
				m_flNextGrenadeCheck = gpGlobals->time + 6;// wait six seconds before even looking again to see if a grenade can be thrown.
		}
		break;

		case HGRUNT_ALLY_AE_GREN_DROP:
		{
			UTIL_MakeVectors( pev->angles );
			CGrenade::ShootTimed( pev, pev->origin + gpGlobals->v_forward * 17 - gpGlobals->v_right * 27 + gpGlobals->v_up * 6, g_vecZero, 3 );
		}
		break;

		case HGRUNT_ALLY_AE_BURST1:
		{
			if ( FBitSet( pev->weapons, FGRUNT_9MMAR ))
			{
				Shoot();
				// the first round of the three round burst plays the sound and puts a sound in the world sound list.
				if( RANDOM_LONG( 0, 1 ) )
				{
					EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "hgrunt/gr_mgun1.wav", 1, ATTN_NORM );
				}
				else
				{
					EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "hgrunt/gr_mgun2.wav", 1, ATTN_NORM );
				}
			}
			else if ( FBitSet( pev->weapons, FGRUNT_SHOTGUN ))
			{
				Shotgun( );

				EMIT_SOUND(ENT(pev), CHAN_WEAPON, "weapons/sbarrel1.wav", 1, ATTN_NORM );
			}
			else
			{
				M249( );
			}

			CSoundEnt::InsertSound ( bits_SOUND_COMBAT, pev->origin, 384, 0.3 );
		}
		break;

		case HGRUNT_ALLY_AE_BURST2:
		case HGRUNT_ALLY_AE_BURST3:
			if ( FBitSet( pev->weapons, FGRUNT_9MMAR ))
				Shoot();
			else if ( FBitSet( pev->weapons, FGRUNT_M249 ))
				M249();
			break;

		case HGRUNT_ALLY_AE_KICK:
		{
			KickImpl(gSkillData.fgruntDmgKick);
		}
		break;

		case HGRUNT_ALLY_AE_CAUGHT_ENEMY:
		{
			if ( FOkToSpeak() )
			{
				SENTENCEG_PlayRndSz(ENT(pev), SentenceByNumber(FGRUNT_SENT_ALERT), FGRUNT_SENTENCE_VOLUME, ATTN_NORM, 0, m_voicePitch);
				JustSpoke();
			}

		}

		default:
			CTalkMonster::HandleAnimEvent( pEvent );
			break;
	}
}

//=========================================================
// Spawn
//=========================================================
void CHFGrunt :: Spawn()
{
	Precache( );

	SpawnHelper("models/hgrunt_opfor.mdl", gSkillData.fgruntHealth);

	if ( m_iHead <= -2 )
	{
		// skip major and MP heads
		m_iHead = RANDOM_LONG(0, FG_HEAD_SAW_BLACK+1);
		if (m_iHead == FG_HEAD_SAW_BLACK+1) {
			m_iHead = FG_HEAD_BERET_BLACK;
		}
	}
	else if ( m_iHead == -1 )
	{
		if (FBitSet(pev->spawnflags, SF_SQUADMONSTER_LEADER))
		{
			m_iHead = RANDOM_LONG(0,1) ? FG_HEAD_BERET : FG_HEAD_BERET_BLACK;
		}
		else if (FBitSet(pev->weapons, FGRUNT_SHOTGUN))
		{
			m_iHead = FG_HEAD_SHOTGUN;
		}
		else if (FBitSet(pev->weapons, FGRUNT_9MMAR))
		{
			m_iHead = FG_HEAD_MASK;
		}
		else if (FBitSet(pev->weapons, FGRUNT_M249))
		{
			m_iHead = RANDOM_LONG(FG_HEAD_SAW, FG_HEAD_SAW_BLACK);
		}
		else
			m_iHead = FG_HEAD_MASK;
	}
	else if ( m_iHead >= FG_HEAD_COUNT )
		m_iHead = FG_HEAD_MASK;

	if ( pev->weapons <= 0 )
	{
		pev->weapons = FGRUNT_9MMAR;
	}
	if (FBitSet( pev->weapons, FGRUNT_SHOTGUN ))
	{
		SetBodygroup( FG_GUN_GROUP, FG_GUN_SHOTGUN );
		SetBodygroup( FG_TORSO_GROUP, FG_TORSO_SHOTGUN );
		m_cClipSize		= 8;
	}
	if (FBitSet( pev->weapons, FGRUNT_9MMAR ))
	{
		SetBodygroup( FG_GUN_GROUP, FG_GUN_MP5 );
		m_cClipSize	= FGRUNT_CLIP_SIZE;
	}
	if (FBitSet( pev->weapons, FGRUNT_M249 ))
	{
		SetBodygroup( FG_GUN_GROUP, FG_GUN_SAW );
		SetBodygroup( FG_TORSO_GROUP, FG_TORSO_M249 );
		m_cClipSize	= FGRUNT_CLIP_SIZE;
	}

	SetBodygroup( FG_HEAD_GROUP, m_iHead );

	m_cAmmoLoaded		= m_cClipSize;

	MonsterInit();
	SetUse( &CTalkMonster::FollowerUse );
}

void CHFGrunt::SpawnHelper(const char *model, float health)
{
	SET_MODEL( ENT( pev ), model );
	UTIL_SetSize(pev, VEC_HUMAN_HULL_MIN, VEC_HUMAN_HULL_MAX);

	pev->solid			= SOLID_SLIDEBOX;
	pev->movetype		= MOVETYPE_STEP;
	m_bloodColor = BLOOD_COLOR_RED;
	pev->health = health;
	pev->view_ofs		= Vector ( 0, 0, 50 );// position of the eyes relative to monster's origin.
	m_flFieldOfView		= VIEW_FIELD_WIDE; // NOTE: we need a wide field of view so npc will notice player and say hello
	m_MonsterState		= MONSTERSTATE_NONE;
	m_flNextGrenadeCheck = gpGlobals->time + 1;
	m_flNextPainTime	= gpGlobals->time;

	m_afCapability		= bits_CAP_HEAR | bits_CAP_SQUAD | bits_CAP_TURN_HEAD | bits_CAP_DOORS_GROUP;

	m_fEnemyEluded		= FALSE;
	m_fFirstEncounter	= TRUE;// this is true when the grunt spawns, because he hasn't encountered an enemy yet.

	m_HackedGunPos = Vector ( 0, 0, 55 );
	m_flLastHitByPlayer = gpGlobals->time;
	m_iPlayerHits = 0;
}

//=========================================================
// Precache - precaches all resources this monster needs
//=========================================================
void CHFGrunt :: Precache()
{
	PRECACHE_MODEL("models/hgrunt_opfor.mdl");

	PRECACHE_SOUND( "hgrunt/gr_mgun1.wav" );
	PRECACHE_SOUND( "hgrunt/gr_mgun2.wav" );

	PRECACHE_SOUND("weapons/saw_fire1.wav" );
	PRECACHE_SOUND("weapons/saw_fire2.wav" );
	PRECACHE_SOUND("weapons/saw_fire3.wav" );

	PrecacheHelper();

	PRECACHE_SOUND("hgrunt/gr_reload1.wav");

	PRECACHE_SOUND("weapons/saw_reload2.wav");

	PRECACHE_SOUND("weapons/glauncher.wav");

	PRECACHE_SOUND("weapons/sbarrel1.wav");

	PRECACHE_SOUND("zombie/claw_miss2.wav");// because we use the basemonster SWIPE animation event

	m_iShotgunShell = PRECACHE_MODEL ("models/shotgunshell.mdl");// shotgun shell
	m_iM249Shell = PRECACHE_MODEL ("models/saw_shell.mdl");// saw shell
	m_iM249Link = PRECACHE_MODEL ("models/saw_link.mdl");// saw link

	TalkInit();
	switch ( m_iHead ) {
	case FG_HEAD_SHOTGUN:
	case FG_HEAD_SAW_BLACK:
	case FG_HEAD_BERET_BLACK:
		m_voicePitch = 90;
		break;
	default:
		m_voicePitch = 100;
		break;
	}

	CTalkMonster::Precache();
}

void CHFGrunt::PrecacheHelper()
{
	PRECACHE_SOUND("fgrunt/gr_pain1.wav");
	PRECACHE_SOUND("fgrunt/gr_pain2.wav");
	PRECACHE_SOUND("fgrunt/gr_pain3.wav");
	PRECACHE_SOUND("fgrunt/gr_pain4.wav");
	PRECACHE_SOUND("fgrunt/gr_pain5.wav");
	PRECACHE_SOUND("fgrunt/gr_pain6.wav");

	PRECACHE_SOUND("fgrunt/death1.wav");
	PRECACHE_SOUND("fgrunt/death2.wav");
	PRECACHE_SOUND("fgrunt/death3.wav");
	PRECACHE_SOUND("fgrunt/death4.wav");
	PRECACHE_SOUND("fgrunt/death5.wav");
	PRECACHE_SOUND("fgrunt/death6.wav");

	PRECACHE_SOUND("fgrunt/medic.wav");

	m_iBrassShell = PRECACHE_MODEL ("models/shell.mdl");// brass shell
}

// Init talk data
void CHFGrunt :: TalkInit()
{
	CTalkMonster::TalkInit();

	m_szGrp[TLK_ANSWER]  =	"FG_ANSWER";
	m_szGrp[TLK_QUESTION] =	"FG_QUESTION";
	m_szGrp[TLK_IDLE] =		"FG_IDLE";
	m_szGrp[TLK_STARE] =	"FG_STARE";
	m_szGrp[TLK_USE] =		"FG_OK";
	m_szGrp[TLK_UNUSE] =	"FG_WAIT";
	//m_szGrp[TLK_DECLINE] =	"FG_STOP";
	m_szGrp[TLK_STOP] =		"FG_STOP";

	/* FG_SCARED in opfor has sentences more suitable for FG_HEAR.
	 * Disabling for now.
	*/
	//m_szGrp[TLK_NOSHOOT] =	"FG_SCARED";
	m_szGrp[TLK_HELLO] =	"FG_HELLO";

	m_szGrp[TLK_PLHURT1] =	"FG_CURE";
	m_szGrp[TLK_PLHURT2] =	"FG_CURE";
	m_szGrp[TLK_PLHURT3] =	"FG_CURE";

	m_szGrp[TLK_SMELL] =	"FG_SMELL";

	m_szGrp[TLK_WOUND] =	"FG_WOUND";
	m_szGrp[TLK_MORTAL] =	"FG_MORTAL";
}

//=========================================================
// PainSound
//=========================================================
void CHFGrunt :: PainSound ( void )
{
	if ( gpGlobals->time > m_flNextPainTime )
	{
		switch ( RANDOM_LONG(0,5) )
		{
			case 0: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "fgrunt/gr_pain1.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
			case 1: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "fgrunt/gr_pain2.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
			case 2: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "fgrunt/gr_pain3.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
			case 3: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "fgrunt/gr_pain4.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
			case 4: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "fgrunt/gr_pain5.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
			case 5: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "fgrunt/gr_pain6.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
		}
		m_flNextPainTime = gpGlobals->time + 1;
	}
}

void CHFGrunt::AlertSound()
{
	if (m_hEnemy !=0 && FOkToSpeak())
	{
		SENTENCEG_PlayRndSz( ENT(pev), "FG_ATTACK", FGRUNT_SENTENCE_VOLUME, ATTN_NORM, 0, m_voicePitch);
	}
}

//=========================================================
// DeathSound
//=========================================================
void CHFGrunt :: DeathSound ( void )
{
	switch (RANDOM_LONG(0,5))
	{
	case 0: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "fgrunt/death1.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
	case 1: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "fgrunt/death2.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
	case 2: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "fgrunt/death3.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
	case 3: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "fgrunt/death4.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
	case 4: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "fgrunt/death5.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
	case 5: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "fgrunt/death6.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
	}
}


void CHFGrunt::IdleSound()
{
	if (FOkToSpeak() && (g_fGruntAllyQuestion || RANDOM_LONG(0,1)))
	{
		const float duration = RANDOM_FLOAT(1.5, 2.5);
		if (g_fGruntAllyQuestion)
		{
			switch (g_fGruntAllyQuestion) {
			case 1:
				PlaySentence( "FG_CLEAR", duration, FGRUNT_SENTENCE_VOLUME, ATTN_IDLE );
				break;
			case 2:
				PlaySentence( m_szGrp[TLK_ANSWER], duration, FGRUNT_SENTENCE_VOLUME, ATTN_IDLE );
				break;
			default:
				break;
			}
			g_fGruntAllyQuestion = 0;
		}
		else
		{
			switch (RANDOM_LONG(0,2)) {
			case 0:
				PlaySentence( "FG_CHECK", duration, FGRUNT_SENTENCE_VOLUME, ATTN_IDLE );
				g_fGruntAllyQuestion = 1;
				break;
			case 1:
				PlaySentence( m_szGrp[TLK_QUESTION], duration, FGRUNT_SENTENCE_VOLUME, ATTN_IDLE );
				g_fGruntAllyQuestion = 2;
				break;
			case 2:
				PlaySentence( m_szGrp[TLK_IDLE], duration, FGRUNT_SENTENCE_VOLUME, ATTN_IDLE );
				break;
			default:
				break;
			}
		}
		m_iSentence = FGRUNT_SENT_NONE;
	}
}

//=========================================================
// TraceAttack - make sure we're not taking it in the helmet
//=========================================================
void CHFGrunt :: TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType)
{
	// reduce damage on vest
	if (ptr->iHitgroup == HITGROUP_CHEST || ptr->iHitgroup == HITGROUP_STOMACH)
	{
		if (bitsDamageType & ( DMG_BULLET | DMG_SLASH | DMG_BLAST ))
		{
			flDamage *= 0.5;
		}
	}
	// check for helmet shot
	if (ptr->iHitgroup == 11)
	{
		// make sure we're wearing one
		if (bitsDamageType & (DMG_BULLET | DMG_SLASH | DMG_BLAST | DMG_CLUB))
		{
			// absorb damage
			flDamage -= 20;
			if (flDamage <= 0)
			{
				UTIL_Ricochet( ptr->vecEndPos, 1.0 );
				flDamage = 0.01;
			}
		}
		// it's head shot anyways
		ptr->iHitgroup = HITGROUP_HEAD;
	}
	CTalkMonster::TraceAttack( pevAttacker, flDamage, vecDir, ptr, bitsDamageType );
}
//=========================================================
// TakeDamage - overridden for the grunt because the grunt
// needs to forget that he is in cover if he's hurt. (Obviously
// not in a safe place anymore).
//=========================================================
int CHFGrunt :: TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
{
	Forget( bits_MEMORY_INCOVER );

	int ret = CTalkMonster::TakeDamage(pevInflictor, pevAttacker, flDamage, bitsDamageType);
	if( !IsAlive() || pev->deadflag == DEAD_DYING )
		return ret;

	if( m_MonsterState != MONSTERSTATE_PRONE && ( pevAttacker->flags & FL_CLIENT ) )
	{
		// This is a heurstic to determine if the player intended to harm me
		// If I have an enemy, we can't establish intent (may just be crossfire)
		if( m_hEnemy == 0 )
		{
			// If the player was facing directly at me, or I'm already suspicious, get mad
			if( ( m_afMemory & bits_MEMORY_SUSPICIOUS ) || IsFacing( pevAttacker, pev->origin ) )
			{
				if (gpGlobals->time - m_flLastHitByPlayer < 4.0 && m_iPlayerHits >= 3)
				{
					// Alright, now I'm pissed!
					PlaySentence( "FG_MAD", 4, VOL_NORM, ATTN_NORM );

					Remember( bits_MEMORY_PROVOKED );
					StopFollowing( TRUE );
				}
			}
			else
			{
				if ( gpGlobals->time - m_flLastHitByPlayer >= 4.0 )
					m_iPlayerHits = 0;
				m_iPlayerHits++;
				m_flLastHitByPlayer = gpGlobals->time;

				// Hey, be careful with that
				PlaySentence( "FG_SHOT", 4, VOL_NORM, ATTN_NORM );
				Remember( bits_MEMORY_SUSPICIOUS );
			}
		}
		else if( !( m_hEnemy->IsPlayer()) && pev->deadflag == DEAD_NO )
		{
			PlaySentence( "FG_SHOT", 4, VOL_NORM, ATTN_NORM );
		}
	}
	return ret;
}

//=========================================================
// AI Schedules Specific to this monster
//=========================================================

Schedule_t* CHFGrunt :: GetScheduleOfType ( int Type )
{
	Schedule_t *psched;

	switch( Type )
	{
	// Hook these to make a looping schedule
	case SCHED_TARGET_FACE:
		// call base class default so that barney will talk
		// when 'used'
		psched = CTalkMonster::GetScheduleOfType( Type );

		if( psched == slIdleStand )
			return slGruntFaceTarget;	// override this for different target face behavior
		else
			return psched;
	case SCHED_TARGET_CHASE:
		return slGruntFollow;
	case SCHED_IDLE_STAND:
		// call base class default so that scientist will talk
		// when standing during idle
		psched = CTalkMonster::GetScheduleOfType( Type );

		if( psched == slIdleStand )
		{
			// just look straight ahead.
			return slIdleGruntStand;
		}
		else
			return psched;
	case SCHED_TAKE_COVER_FROM_ENEMY:
		{
			return &slFGruntTakeCover[ 0 ];
		}
		break;
	case SCHED_TAKE_COVER_FROM_BEST_SOUND:
		{
			return &slFGruntTakeCoverFromBestSound[ 0 ];
		}
		break;
	case SCHED_HGRUNT_ALLY_TAKECOVER_FAILED:
		{
			if ( HasConditions( bits_COND_CAN_RANGE_ATTACK1 ) && OccupySlot( bits_SLOTS_HGRUNT_ENGAGE ) )
			{
				return GetScheduleOfType( SCHED_RANGE_ATTACK1 );
			}
			else
			{
				return GetScheduleOfType ( SCHED_FAIL );
			}
		}
		break;
	case SCHED_HGRUNT_ALLY_ELOF_FAIL:
		{
			return GetScheduleOfType( SCHED_RANGE_ATTACK1 );
		}
		break;
	case SCHED_HGRUNT_ALLY_ESTABLISH_LINE_OF_FIRE:
		{
			return &slFGruntEstablishLineOfFire[ 0 ];
		}
		break;
	case SCHED_RANGE_ATTACK1:
		{
			// randomly stand or crouch
			if (RANDOM_LONG(0,9) == 0)
				m_fStanding = RANDOM_LONG(0,1);

			if (m_fStanding)
				return &slFGruntRangeAttack1B[ 0 ];
			else
				return &slFGruntRangeAttack1A[ 0 ];
		}
		break;
	case SCHED_RANGE_ATTACK2:
		{
			return &slFGruntRangeAttack2[ 0 ];
		}
		break;
	case SCHED_COMBAT_FACE:
		{
			return &slFGruntCombatFace[ 0 ];
		}
		break;
	case SCHED_HGRUNT_ALLY_WAIT_FACE_ENEMY:
		{
			return &slFGruntWaitInCover[ 0 ];
		}
	case SCHED_HGRUNT_ALLY_SWEEP:
		{
			return &slFGruntSweep[ 0 ];
		}
		break;
	case SCHED_HGRUNT_ALLY_COVER_AND_RELOAD:
		{
			return &slFGruntHideReload[ 0 ];
		}
		break;
	case SCHED_HGRUNT_ALLY_FOUND_ENEMY:
		{
			return &slFGruntFoundEnemy[ 0 ];
		}
		break;
	case SCHED_VICTORY_DANCE:
		{
			if ( InSquad() )
			{
				if ( !IsLeader() )
				{
					return &slFGruntFail[ 0 ];
				}
			}
			if ( m_hTalkTarget != 0 )
			{
				return &slFGruntFail[ 0 ];
			}

			return &slFGruntVictoryDance[ 0 ];
		}
		break;
	case SCHED_HGRUNT_ALLY_SUPPRESS:
		{
			if ( m_fFirstEncounter )
			{
				m_fFirstEncounter = FALSE;// after first encounter, leader won't issue handsigns anymore when he has a new enemy
				return &slFGruntSignalSuppress[ 0 ];
			}
			else
			{
				return &slFGruntSuppress[ 0 ];
			}
		}
		break;
	case SCHED_FAIL:
		{
			if ( m_hEnemy != 0 )
			{
				// grunt has an enemy, so pick a different default fail schedule most likely to help recover.
				return &slFGruntCombatFail[ 0 ];
			}

			return &slFGruntFail[ 0 ];
		}
		break;
	case SCHED_HGRUNT_ALLY_REPEL:
		{
			if (pev->velocity.z > -128)
				pev->velocity.z -= 32;
			return &slFGruntRepel[ 0 ];
		}
		break;
	case SCHED_HGRUNT_ALLY_REPEL_ATTACK:
		{
			if (pev->velocity.z > -128)
				pev->velocity.z -= 32;
			return &slFGruntRepelAttack[ 0 ];
		}
		break;
	case SCHED_HGRUNT_ALLY_REPEL_LAND:
		{
			return &slFGruntRepelLand[ 0 ];
		}
		break;
	case SCHED_HGRUNT_ALLY_FIND_MEDIC:
			{
				return slGruntFindMedic;
			}
			break;
	default:
		{
			return CTalkMonster :: GetScheduleOfType ( Type );
		}
	}
}
//=========================================================
// SetActivity
//=========================================================
void CHFGrunt :: SetActivity ( Activity NewActivity )
{
	int	iSequence = ACTIVITY_NOT_AVAILABLE;
	void *pmodel = GET_MODEL_PTR( ENT(pev) );

	switch ( NewActivity)
	{
	case ACT_RANGE_ATTACK1:
		// grunt is either shooting standing or shooting crouched
		if (FBitSet( pev->weapons, FGRUNT_SHOTGUN))
		{
			if ( m_fStanding )
			{
				// get aimable sequence
				iSequence = LookupSequence( "standing_shotgun" );
			}
			else
			{
				// get crouching shoot
				iSequence = LookupSequence( "crouching_shotgun" );
			}
		}
		else if (FBitSet( pev->weapons, FGRUNT_M249 ))
		{
			if ( m_fStanding )
			{
				// get aimable sequence
				iSequence = LookupSequence( "standing_saw" );
			}
			else
			{
				// get crouching shoot
				iSequence = LookupSequence( "crouching_saw" );
			}
		}
		else
		{
			if ( m_fStanding )
			{
				// get aimable sequence
				iSequence = LookupSequence( "standing_mp5" );
			}
			else
			{
				// get crouching shoot
				iSequence = LookupSequence( "crouching_mp5" );
			}
		}
		break;
	case ACT_RANGE_ATTACK2:
		// grunt is going to a secondary long range attack. This may be a thrown
		// grenade or fired grenade, we must determine which and pick proper sequence
		if ( pev->weapons & FGRUNT_HANDGRENADE )
		{
			// get toss anim
			iSequence = LookupSequence( "throwgrenade" );
		}
		else if ( pev->weapons & FGRUNT_GRENADELAUNCHER )
		{
			// get launch anim
			iSequence = LookupSequence( "launchgrenade" );
		}
		break;
	case ACT_RUN:
		if ( pev->health <= FGRUNT_LIMP_HEALTH )
		{
			// limp!
			iSequence = LookupActivity ( ACT_RUN_HURT );
		}
		else
		{
			iSequence = LookupActivity ( NewActivity );
		}
		break;
	case ACT_WALK:
		if ( pev->health <= FGRUNT_LIMP_HEALTH )
		{
			// limp!
			iSequence = LookupActivity ( ACT_WALK_HURT );
		}
		else
		{
			iSequence = LookupActivity ( NewActivity );
		}
		break;
	case ACT_IDLE:
		if ( m_MonsterState == MONSTERSTATE_COMBAT )
		{
			NewActivity = ACT_IDLE_ANGRY;
		}
		iSequence = LookupActivity ( NewActivity );
		break;
	default:
		iSequence = LookupActivity ( NewActivity );
		break;
	}

	m_Activity = NewActivity; // Go ahead and set this so it doesn't keep trying when the anim is not present

	// Set to the desired anim, or default anim if the desired is not present
	if ( iSequence > ACTIVITY_NOT_AVAILABLE )
	{
		if ( pev->sequence != iSequence || !m_fSequenceLoops )
		{
			pev->frame = 0;
		}

		pev->sequence		= iSequence;	// Set to the reset anim (if it's there)
		ResetSequenceInfo( );
		SetYawSpeed();
	}
	else
	{
		// Not available try to get default anim
		ALERT ( at_console, "%s has no sequence for act:%d\n", STRING(pev->classname), NewActivity );
		pev->sequence		= 0;	// Set to the reset anim (if it's there)
	}
}
//=========================================================
// GetSchedule - Decides which type of schedule best suits
// the monster's current state and conditions. Then calls
// monster's member function to get a pointer to a schedule
// of the proper type.
//=========================================================
Schedule_t* CHFGrunt::PrioritizedSchedule()
{
	// flying? If PRONE, barnacle has me. IF not, it's assumed I am rapelling.
	if ( pev->movetype == MOVETYPE_FLY && m_MonsterState != MONSTERSTATE_PRONE )
	{
		if (pev->flags & FL_ONGROUND)
		{
			// just landed
			pev->movetype = MOVETYPE_STEP;
			return GetScheduleOfType ( SCHED_HGRUNT_ALLY_REPEL_LAND );
		}
		else
		{
			// repel down a rope,
			if ( m_MonsterState == MONSTERSTATE_COMBAT )
				return GetScheduleOfType ( SCHED_HGRUNT_ALLY_REPEL_ATTACK );
			else
				return GetScheduleOfType ( SCHED_HGRUNT_ALLY_REPEL );
		}
	}

	// grunts place HIGH priority on running away from danger sounds.
	if ( HasConditions(bits_COND_HEAR_SOUND) )
	{
		CSound *pSound;
		pSound = PBestSound();

		ASSERT( pSound != NULL );
		if ( pSound)
		{
			if (pSound->m_iType & bits_SOUND_DANGER)
			{
				// dangerous sound nearby!

				//!!!KELLY - currently, this is the grunt's signal that a grenade has landed nearby,
				// and the grunt should find cover from the blast
				// good place for "SHIT!" or some other colorful verbal indicator of dismay.
				// It's not safe to play a verbal order here "Scatter", etc cause
				// this may only affect a single individual in a squad.

				if (FOkToSpeak())
				{
					SENTENCEG_PlayRndSz( ENT(pev), SentenceByNumber(FGRUNT_SENT_GREN), FGRUNT_SENTENCE_VOLUME, ATTN_NORM, 0, m_voicePitch);
					JustSpoke();
				}
				return GetScheduleOfType( SCHED_TAKE_COVER_FROM_BEST_SOUND );
			}
		}
	}
	return NULL;
}

Schedule_t *CHFGrunt :: GetSchedule ( void )
{
	Schedule_t* prioritizedSchedule = PrioritizedSchedule();
	if (prioritizedSchedule)
		return prioritizedSchedule;

	if ( HasConditions( bits_COND_ENEMY_DEAD ) && FOkToSpeak() )
	{
		PlaySentence( "FG_KILL", 4, VOL_NORM, ATTN_NORM );
	}

	switch( m_MonsterState )
	{
	case MONSTERSTATE_COMBAT:
		{
// dead enemy
			if ( HasConditions( bits_COND_ENEMY_DEAD ) )
			{
				// call base class, all code to handle dead enemies is centralized there.
				return CTalkMonster::GetSchedule();
			}
// new enemy
			if ( HasConditions(bits_COND_NEW_ENEMY) )
			{
				if ( InSquad() )
				{
					MySquadLeader()->m_fEnemyEluded = FALSE;

					if ( !IsLeader() )
					{
						if ( HasConditions ( bits_COND_CAN_RANGE_ATTACK1 ) )
						{
							return GetScheduleOfType ( SCHED_HGRUNT_ALLY_SUPPRESS );
						}
						else
						{
							return GetScheduleOfType ( SCHED_HGRUNT_ALLY_ESTABLISH_LINE_OF_FIRE );
						}
					}
					else
					{
						//!!!KELLY - the leader of a squad of grunts has just seen the player or a
						// monster and has made it the squad's enemy. You
						// can check pev->flags for FL_CLIENT to determine whether this is the player
						// or a monster. He's going to immediately start
						// firing, though. If you'd like, we can make an alternate "first sight"
						// schedule where the leader plays a handsign anim
						// that gives us enough time to hear a short sentence or spoken command
						// before he starts pluggin away.
						if (FOkToSpeak())// && RANDOM_LONG(0,1))
						{

							if (m_hEnemy != 0)
							{
								if ( ( m_hEnemy->Classify() != CLASS_PLAYER_ALLY ) &&
									 ( m_hEnemy->Classify() != CLASS_HUMAN_PASSIVE ) &&
									 ( m_hEnemy->Classify() != CLASS_HUMAN_MILITARY ) &&
									 ( m_hEnemy->Classify() != CLASS_MACHINE ) )
									SENTENCEG_PlayRndSz( ENT(pev), SentenceByNumber(FGRUNT_SENT_MONSTER), FGRUNT_SENTENCE_VOLUME, ATTN_NORM, 0, m_voicePitch);
								else
									SENTENCEG_PlayRndSz( ENT(pev), SentenceByNumber(FGRUNT_SENT_ALERT), FGRUNT_SENTENCE_VOLUME, ATTN_NORM, 0, m_voicePitch);
							}

							JustSpoke();
						}

						if ( HasConditions ( bits_COND_CAN_RANGE_ATTACK1 ) )
						{
							return GetScheduleOfType ( SCHED_HGRUNT_ALLY_SUPPRESS );
						}
						else
						{
							return GetScheduleOfType ( SCHED_HGRUNT_ALLY_ESTABLISH_LINE_OF_FIRE );
						}
					}
				}
			}
// no ammo
			else if ( HasConditions ( bits_COND_NO_AMMO_LOADED ) )
			{
				//!!!KELLY - this individual just realized he's out of bullet ammo.
				// He's going to try to find cover to run to and reload, but rarely, if
				// none is available, he'll drop and reload in the open here.
				return GetScheduleOfType ( SCHED_HGRUNT_ALLY_COVER_AND_RELOAD );
			}

// damaged just a little
			else if ( HasConditions( bits_COND_LIGHT_DAMAGE ) )
			{
				// if hurt:
				// 90% chance of taking cover
				// 10% chance of flinch.

				int iPercent = RANDOM_LONG(0,99);

				if ( iPercent <= 90 && m_hEnemy != 0 )
				{
					if (FOkToSpeak())
					{
						m_iSentence = FGRUNT_SENT_COVER;
					}
					// only try to take cover if we actually have an enemy!

					return GetScheduleOfType( SCHED_TAKE_COVER_FROM_ENEMY );
				}
				else
				{
					return GetScheduleOfType( SCHED_SMALL_FLINCH );
				}
			}
// can kick
			else if ( HasConditions ( bits_COND_CAN_MELEE_ATTACK1 ) )
			{
				return GetScheduleOfType ( SCHED_MELEE_ATTACK1 );
			}
// can grenade launch

			else if ( FBitSet( pev->weapons, FGRUNT_GRENADELAUNCHER) && HasConditions ( bits_COND_CAN_RANGE_ATTACK2 ) && OccupySlot( bits_SLOTS_HGRUNT_GRENADE ) )
			{
				// shoot a grenade if you can
				return GetScheduleOfType( SCHED_RANGE_ATTACK2 );
			}
// can shoot
			else if ( HasConditions ( bits_COND_CAN_RANGE_ATTACK1 ) )
			{
				if ( InSquad() )
				{
					// if the enemy has eluded the squad and a squad member has just located the enemy
					// and the enemy does not see the squad member, issue a call to the squad to waste a
					// little time and give the player a chance to turn.
					if ( MySquadLeader()->m_fEnemyEluded && !HasConditions ( bits_COND_ENEMY_FACING_ME ) )
					{
						MySquadLeader()->m_fEnemyEluded = FALSE;
						return GetScheduleOfType ( SCHED_HGRUNT_ALLY_FOUND_ENEMY );
					}
				}
				if ( OccupySlot ( bits_SLOTS_HGRUNT_ENGAGE ) )
				{
					// try to take an available ENGAGE slot
					return GetScheduleOfType( SCHED_RANGE_ATTACK1 );
				}
				else if ( HasConditions ( bits_COND_CAN_RANGE_ATTACK2 ) && OccupySlot( bits_SLOTS_HGRUNT_GRENADE ) )
				{
					// throw a grenade if can and no engage slots are available
					return GetScheduleOfType( SCHED_RANGE_ATTACK2 );
				}
				else
				{
					// hide!
					return GetScheduleOfType( SCHED_TAKE_COVER_FROM_ENEMY );
				}
			}
// can't see enemy
			else if ( HasConditions( bits_COND_ENEMY_OCCLUDED ) )
			{
				if ( HasConditions( bits_COND_CAN_RANGE_ATTACK2 ) && OccupySlot( bits_SLOTS_HGRUNT_GRENADE ) )
				{
					//!!!KELLY - this grunt is about to throw or fire a grenade at the player. Great place for "fire in the hole"  "frag out" etc
					if (FOkToSpeak())
					{
						SENTENCEG_PlayRndSz( ENT(pev), SentenceByNumber(FGRUNT_SENT_THROW), FGRUNT_SENTENCE_VOLUME, ATTN_NORM, 0, m_voicePitch);
						JustSpoke();
					}
					return GetScheduleOfType( SCHED_RANGE_ATTACK2 );
				}
				else if ( OccupySlot( bits_SLOTS_HGRUNT_ENGAGE ) )
				{
					if( FOkToSpeak() )
					{
						m_iSentence = FGRUNT_SENT_CHARGE;
					}
					return GetScheduleOfType( SCHED_HGRUNT_ALLY_ESTABLISH_LINE_OF_FIRE );
				}
				else
				{
					//!!!KELLY - grunt is going to stay put for a couple seconds to see if
					// the enemy wanders back out into the open, or approaches the
					// grunt's covered position. Good place for a taunt, I guess?
					if (FOkToSpeak() && RANDOM_LONG(0,1))
					{
						SENTENCEG_PlayRndSz( ENT(pev), SentenceByNumber(FGRUNT_SENT_TAUNT), FGRUNT_SENTENCE_VOLUME, ATTN_NORM, 0, m_voicePitch);
						JustSpoke();
					}
					return GetScheduleOfType( SCHED_STANDOFF );
				}
			}

			if ( HasConditions( bits_COND_SEE_ENEMY ) && !HasConditions ( bits_COND_CAN_RANGE_ATTACK1 ) )
			{
				return GetScheduleOfType ( SCHED_HGRUNT_ALLY_ESTABLISH_LINE_OF_FIRE );
			}
		}
		break;
	case MONSTERSTATE_ALERT:
	case MONSTERSTATE_IDLE:
		if ( HasConditions ( bits_COND_NO_AMMO_LOADED ) )
		{
			return GetScheduleOfType ( SCHED_RELOAD );
		}
		if ( WantsToCallMedic() )
		{
			return GetScheduleOfType( SCHED_HGRUNT_ALLY_FIND_MEDIC );
		}

		if( m_hEnemy == 0 && IsFollowing() )
		{
			if( !m_hTargetEnt->IsAlive() )
			{
				// UNDONE: Comment about the recently dead player here?
				StopFollowing( FALSE );
				break;
			}
			else
			{
				if( HasConditions( bits_COND_CLIENT_PUSH ) )
				{
					return GetScheduleOfType( SCHED_MOVE_AWAY_FOLLOW );
				}
				return GetScheduleOfType( SCHED_TARGET_FACE );
			}
		}

		if( HasConditions( bits_COND_CLIENT_PUSH ) )
		{
			return GetScheduleOfType( SCHED_MOVE_AWAY );
		}

		// try to say something about smells
		TrySmellTalk();
		break;
	}

	return CTalkMonster :: GetSchedule();
}
MONSTERSTATE CHFGrunt :: GetIdealState ( void )
{
	return CTalkMonster::GetIdealState();
}

void CHFGrunt::DeclineFollowing( void )
{
	PlaySentence( "FG_POK", 2, VOL_NORM, ATTN_NORM );
}

//=========================================================
// CHFGruntRepel - when triggered, spawns a
// repelling down a line.
//=========================================================

class CTalkMonsterRepel : public CHGruntRepel
{
public:
	void KeyValue(KeyValueData* pkvd);
	void PrepareBeforeSpawn(CBaseEntity* pEntity);

	int Save( CSave &save );
	int Restore( CRestore &restore );
	static TYPEDESCRIPTION m_SaveData[];

	string_t m_iszUse;
	string_t m_iszUnUse;
};

TYPEDESCRIPTION	CTalkMonsterRepel::m_SaveData[] =
{
	DEFINE_FIELD( CTalkMonsterRepel, m_iszUse, FIELD_STRING ),
	DEFINE_FIELD( CTalkMonsterRepel, m_iszUnUse, FIELD_STRING ),
};

IMPLEMENT_SAVERESTORE( CTalkMonsterRepel, CHGruntRepel )

void CTalkMonsterRepel::KeyValue(KeyValueData *pkvd)
{
	if( FStrEq( pkvd->szKeyName, "UseSentence" ) )
	{
		m_iszUse = ALLOC_STRING( pkvd->szValue );
		pkvd->fHandled = TRUE;
	}
	else if( FStrEq( pkvd->szKeyName, "UnUseSentence" ) )
	{
		m_iszUnUse = ALLOC_STRING( pkvd->szValue );
		pkvd->fHandled = TRUE;
	}
	else
		CHGruntRepel::KeyValue( pkvd );
}

void CTalkMonsterRepel::PrepareBeforeSpawn(CBaseEntity *pEntity)
{
	if (FBitSet(pev->spawnflags, SF_MONSTER_PREDISASTER))
	{
		SetBits(pEntity->pev->spawnflags, SF_MONSTER_PREDISASTER);
	}

	CTalkMonster* monster = (CTalkMonster*)pEntity;
	monster->m_iszUse = m_iszUse;
	monster->m_iszUnUse = m_iszUnUse;
}

class CHFGruntRepel : public CTalkMonsterRepel
{
public:
	void KeyValue(KeyValueData* pkvd);
	const char* TrooperName() {
		return "monster_human_grunt_ally";
	}
	void PrepareBeforeSpawn(CBaseEntity* pEntity);

	int Save( CSave &save );
	int Restore( CRestore &restore );
	static TYPEDESCRIPTION m_SaveData[];

	int m_iGruntHead;
};

LINK_ENTITY_TO_CLASS( monster_grunt_ally_repel, CHFGruntRepel )

TYPEDESCRIPTION	CHFGruntRepel::m_SaveData[] =
{
	DEFINE_FIELD( CHFGruntRepel, m_iGruntHead, FIELD_INTEGER ),
};

IMPLEMENT_SAVERESTORE( CHFGruntRepel, CTalkMonsterRepel )

void CHFGruntRepel::KeyValue(KeyValueData *pkvd)
{
	if( FStrEq(pkvd->szKeyName, "head" ) )
	{
		m_iGruntHead = atoi( pkvd->szValue );
		pkvd->fHandled = TRUE;
	}
	else
		CTalkMonsterRepel::KeyValue( pkvd );
}

void CHFGruntRepel::PrepareBeforeSpawn(CBaseEntity *pEntity)
{
	CHFGrunt* grunt = (CHFGrunt*)pEntity;
	grunt->m_iHead = m_iGruntHead;
	CTalkMonsterRepel::PrepareBeforeSpawn(pEntity);
}

class CMedicRepel : public CHFGruntRepel
{
public:
	const char* TrooperName() {
		return "monster_human_medic_ally";
	}
};

LINK_ENTITY_TO_CLASS( monster_medic_ally_repel, CMedicRepel )

class CTorchRepel : public CTalkMonsterRepel
{
public:
	const char* TrooperName() {
		return "monster_human_torch_ally";
	}
};

LINK_ENTITY_TO_CLASS( monster_torch_ally_repel, CTorchRepel )

//=========================================================
// FGrunt Dead PROP
//=========================================================

class CDeadFGrunt : public CBaseMonster
{
public:
	void Spawn( void );
	int	Classify ( void ) { return	CLASS_PLAYER_ALLY; }

	void KeyValue( KeyValueData *pkvd );

	int m_iPose;
	int	m_iHead;
	static const char *m_szPoses[7];
};

const char *CDeadFGrunt::m_szPoses[] = { "deadstomach", "deadside", "deadsitting", "dead_on_back", "hgrunt_dead_stomach", "dead_headcrabed" };

void CDeadFGrunt::KeyValue( KeyValueData *pkvd )
{
	if( FStrEq( pkvd->szKeyName, "pose" ) )
	{
		m_iPose = atoi( pkvd->szValue );
		pkvd->fHandled = TRUE;
	}
	else if (FStrEq(pkvd->szKeyName, "head"))
	{
		m_iHead = atoi( pkvd->szValue );
		pkvd->fHandled = TRUE;
	}
	else
		CBaseMonster::KeyValue( pkvd );
}

LINK_ENTITY_TO_CLASS( monster_human_grunt_ally_dead, CDeadFGrunt )

//=========================================================
// ********** DeadFGrunt SPAWN **********
//=========================================================
void CDeadFGrunt :: Spawn( )
{
	PRECACHE_MODEL( "models/hgrunt_opfor.mdl" );
	SET_MODEL( ENT( pev ), "models/hgrunt_opfor.mdl" );

	pev->effects = 0;
	pev->yaw_speed = 8;
	pev->sequence = 0;
	m_bloodColor = BLOOD_COLOR_RED;

	pev->sequence = LookupSequence( m_szPoses[m_iPose] );
	if( pev->sequence == -1 )
	{
		ALERT( at_console, "Dead barney with bad pose\n" );
	}
	// Corpses have less health
	pev->health = 8;//gSkillData.barneyHealth;

	if ( pev->weapons <= 0 )
	{
		SetBodygroup( FG_GUN_GROUP, FG_GUN_NONE );
	}
	if (FBitSet( pev->weapons, FGRUNT_SHOTGUN ))
	{
		SetBodygroup( FG_GUN_GROUP, FG_GUN_SHOTGUN );
		SetBodygroup( FG_TORSO_GROUP, FG_TORSO_SHOTGUN );
	}
	if (FBitSet( pev->weapons, FGRUNT_9MMAR ))
	{
		SetBodygroup( FG_GUN_GROUP, FG_GUN_MP5 );
	}
	if (FBitSet( pev->weapons, FGRUNT_M249 ))
	{
		SetBodygroup( FG_GUN_GROUP, FG_GUN_SAW );
		SetBodygroup( FG_TORSO_GROUP, FG_TORSO_M249 );
	}

	if ( m_iHead <= -2 )
	{
		// skip major and MP heads
		m_iHead = RANDOM_LONG(0, FG_HEAD_SAW_BLACK+1);
		if (m_iHead == FG_HEAD_SAW_BLACK+1) {
			m_iHead = FG_HEAD_BERET_BLACK;
		}
	}
	else if ( m_iHead < 0 || m_iHead >= FG_HEAD_COUNT )
		m_iHead = 0;

	SetBodygroup( FG_HEAD_GROUP, m_iHead );

	MonsterInitDead();
}

#define	TORCH_CLIP_SIZE					7

#define TORCH_EAGLE				( 1 << 0)
#define TORCH_BLOWTORCH			( 1 << 1)

// Weapon group
#define TORCH_GUN_GROUP					2
#define TORCH_GUN_EAGLE					0
#define TORCH_GUN_TORCH					1
#define TORCH_GUN_NONE					2

// Torch specific animation events
#define		TORCH_AE_SHOWGUN		( 17)
#define		TORCH_AE_SHOWTORCH		( 18)
#define		TORCH_AE_HIDETORCH		( 19)
#define		TORCH_AE_ONGAS			( 20)
#define		TORCH_AE_OFFGAS			( 21)

class CTorch : public CHFGrunt
{
public:
	void Spawn( void );
	void Precache( void );
	void HandleAnimEvent( MonsterEvent_t* pEvent );
	BOOL CheckRangeAttack1(float flDot, float flDist);
	BOOL CheckRangeAttack2(float flDot, float flDist);
	void GibMonster();
	void TraceAttack(entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
	void PrescheduleThink();

	void DropMyItems(BOOL isGibbed);

	void MakeGas( void );
	void UpdateGas( void );
	void KillGas( void );

	virtual int		Save( CSave &save );
	virtual int		Restore( CRestore &restore );
	static	TYPEDESCRIPTION m_SaveData[];

	CBeam *m_pBeam;
};

LINK_ENTITY_TO_CLASS( monster_human_torch_ally, CTorch )

TYPEDESCRIPTION	CTorch::m_SaveData[] =
{
	DEFINE_FIELD( CTorch, m_pBeam, FIELD_CLASSPTR ),
};

IMPLEMENT_SAVERESTORE( CTorch, CHFGrunt )

void CTorch::Spawn()
{
	Precache( );

	SpawnHelper("models/hgrunt_torch.mdl", gSkillData.torchHealth);

	if (!pev->weapons)
		pev->weapons = TORCH_EAGLE;

	if ( FBitSet( pev->weapons, TORCH_EAGLE ) )
	{
		pev->body = TORCH_GUN_EAGLE;
	}
	if ( FBitSet( pev->weapons, TORCH_BLOWTORCH ) )
	{
		pev->body = TORCH_GUN_TORCH;
	}
	m_cClipSize = TORCH_CLIP_SIZE;
	m_cAmmoLoaded		= m_cClipSize;
	m_pBeam = NULL;
	MonsterInit();
	SetUse( &CTalkMonster::FollowerUse );
}

void CTorch::Precache()
{
	PRECACHE_MODEL("models/hgrunt_torch.mdl");
	PRECACHE_SOUND("weapons/desert_eagle_fire.wav");
	PRECACHE_SOUND("weapons/desert_eagle_reload.wav");
	PrecacheHelper();
	TalkInit();
	m_voicePitch = 95;
	CTalkMonster::Precache();
}

void CTorch::HandleAnimEvent(MonsterEvent_t *pEvent)
{
	switch ( pEvent->event )
	{
	case TORCH_AE_SHOWTORCH:
		pev->body = 1;
		break;

	case TORCH_AE_SHOWGUN:
		if ( FBitSet( pev->weapons, TORCH_EAGLE ) )
			pev->body = 0;
		else
			pev->body = 1;
		break;

	case TORCH_AE_HIDETORCH:
		pev->body = 2;
		break;

	case TORCH_AE_ONGAS:
		MakeGas ();
		UpdateGas ();
		break;

	case TORCH_AE_OFFGAS:
		KillGas ();
		break;
	case HGRUNT_ALLY_AE_DROP_GUN:
		if ( FBitSet( pev->weapons, TORCH_EAGLE ) )
		{
			DropMyItems(FALSE);
		}
		break;
	case HGRUNT_ALLY_AE_RELOAD:
		EMIT_SOUND( ENT(pev), CHAN_WEAPON, "weapons/desert_eagle_reload.wav", 1, ATTN_NORM );
		m_cAmmoLoaded = m_cClipSize;
		ClearConditions(bits_COND_NO_AMMO_LOADED);
		break;
	case HGRUNT_ALLY_AE_BURST1:
	{
		UTIL_MakeVectors( pev->angles );
		Vector vecShootOrigin = GetGunPosition();
		Vector vecShootDir = ShootAtEnemy( vecShootOrigin );

		Vector angDir = UTIL_VecToAngles( vecShootDir );
		SetBlending( 0, angDir.x );
		pev->effects = EF_MUZZLEFLASH;

		FireBullets( 1, vecShootOrigin, vecShootDir, VECTOR_CONE_2DEGREES, 1024, BULLET_MONSTER_357 );

		int pitchShift = RANDOM_LONG( 0, 20 );
		// Only shift about half the time
		if( pitchShift > 10 )
			pitchShift = 0;
		else
			pitchShift -= 5;
		EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, "weapons/desert_eagle_fire.wav", 1, ATTN_NORM, 0, 100 + pitchShift );
		CSoundEnt::InsertSound ( bits_SOUND_COMBAT, pev->origin, 384, 0.3 );
		m_cAmmoLoaded--;// take away a bullet!
	}
		break;
	case HGRUNT_ALLY_AE_BURST2:
	case HGRUNT_ALLY_AE_BURST3:
		break;
	case HGRUNT_ALLY_AE_KICK:
	{
		KickImpl(gSkillData.torchDmgKick);
	}
	break;
	default:
		CHFGrunt::HandleAnimEvent(pEvent);
		break;
	}
}

BOOL CTorch::CheckRangeAttack1(float flDot, float flDist)
{
	return FBitSet( pev->weapons, TORCH_EAGLE ) && CHFGrunt::CheckRangeAttack1(flDot, flDist);
}

BOOL CTorch::CheckRangeAttack2(float flDot, float flDist)
{
	return FALSE;
}

void CTorch::GibMonster()
{
	if ( FBitSet( pev->weapons, TORCH_EAGLE ) && pev->body != TORCH_GUN_NONE )
	{// throw a gun if the grunt has one
		DropMyItems(TRUE);
	}
	CTalkMonster::GibMonster();
}

void CTorch::DropMyItems(BOOL isGibbed)
{
	if (!isGibbed) {
		pev->body = TORCH_GUN_NONE;
	}
	Vector	vecGunPos;
	Vector	vecGunAngles;
	GetAttachment( 0, vecGunPos, vecGunAngles );
	DropMyItem("weapon_eagle", vecGunPos, vecGunAngles, isGibbed);
}

void CTorch::TraceAttack(entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType)
{
	// check for gas tank
	if (ptr->iHitgroup == 8)
	{
		if (bitsDamageType & (DMG_BULLET | DMG_SLASH | DMG_BLAST | DMG_CLUB))
		{
			bitsDamageType = (DMG_ALWAYSGIB | DMG_BLAST);
			flDamage = pev->health + 1;
			UTIL_Ricochet( ptr->vecEndPos, 1.0 );
			MESSAGE_BEGIN( MSG_PAS, SVC_TEMPENTITY, pev->origin );
				WRITE_BYTE( TE_EXPLOSION );		// This makes a dynamic light and the explosion sprites/sound
				WRITE_COORD( ptr->vecEndPos.x );	// Send to PAS because of the sound
				WRITE_COORD( ptr->vecEndPos.y );
				WRITE_COORD( ptr->vecEndPos.z );
				WRITE_SHORT( g_sModelIndexFireball );
				WRITE_BYTE( 15  ); // scale * 10
				WRITE_BYTE( 15  ); // framerate
				WRITE_BYTE( TE_EXPLFLAG_NONE );
			MESSAGE_END();
			::RadiusDamage ( pev->origin, pev, pev, Q_min(pev->max_health, 75), 125, CLASS_NONE, DMG_BLAST );
			Create( "spark_shower", pev->origin, ptr->vecPlaneNormal, NULL );
		}
	}
	CHFGrunt::TraceAttack( pevAttacker, flDamage, vecDir, ptr, bitsDamageType );
}

void CTorch::PrescheduleThink()
{
	if (m_pBeam)
	{
		UpdateGas();
	}
	CHFGrunt::PrescheduleThink();
}

//=========================================================
// AUTOGENE
//=========================================================
void CTorch::UpdateGas( void )
{
	TraceResult tr;
	Vector			posGun, angleGun;

	if ( m_pBeam )
	{
		UTIL_MakeVectors( pev->angles );

		GetAttachment( 2, posGun, angleGun );

		Vector vecEnd = (gpGlobals->v_forward * 5) + posGun;
		UTIL_TraceLine( posGun, vecEnd, dont_ignore_monsters, edict(), &tr );

		if ( tr.flFraction != 1.0 )
		{
			m_pBeam->DoSparks( tr.vecEndPos, posGun );
			UTIL_DecalTrace(&tr, DECAL_BIGSHOT1 + RANDOM_LONG(0,4));

				MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, tr.vecEndPos );
					WRITE_BYTE( TE_STREAK_SPLASH );
					WRITE_COORD( tr.vecEndPos.x );		// origin
					WRITE_COORD( tr.vecEndPos.y );
					WRITE_COORD( tr.vecEndPos.z );
					WRITE_COORD( tr.vecPlaneNormal.x );	// direction
					WRITE_COORD( tr.vecPlaneNormal.y );
					WRITE_COORD( tr.vecPlaneNormal.z );
					WRITE_BYTE( 10 );	// Streak color 6
					WRITE_SHORT( 60 );	// count
					WRITE_SHORT( 25 );
					WRITE_SHORT( 50 );	// Random velocity modifier
				MESSAGE_END();
		}
		MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY );
			WRITE_BYTE( TE_DLIGHT );
			WRITE_COORD( posGun.x );		// origin
			WRITE_COORD( posGun.y );
			WRITE_COORD( posGun.z );
			WRITE_BYTE( RANDOM_LONG(4, 16) );	// radius
			WRITE_BYTE( 251 );	// R
			WRITE_BYTE( 68 );	// G
			WRITE_BYTE( 36 );	// B
			WRITE_BYTE( 1 );	// life * 10
			WRITE_BYTE( 0 ); // decay
		MESSAGE_END();

		MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY );
			WRITE_BYTE( TE_ELIGHT );
			WRITE_SHORT( entindex( ) + 0x1000 * 3 );		// entity, attachment
			WRITE_COORD( posGun.x );		// origin
			WRITE_COORD( posGun.y );
			WRITE_COORD( posGun.z );
			WRITE_COORD( RANDOM_LONG(8, 12) );	// radius
			WRITE_BYTE( 251 );	// R
			WRITE_BYTE( 68 );	// G
			WRITE_BYTE( 36 );	// B
			WRITE_BYTE( 1 );	// life * 10
			WRITE_COORD( 0 ); // decay
		MESSAGE_END();
	}
}

void CTorch::MakeGas( void )
{
	Vector		posGun, angleGun;
	TraceResult tr;
	Vector vecEndPos;

	UTIL_MakeVectors( pev->angles );
	m_pBeam = CBeam::BeamCreate( g_pModelNameLaser, 7 );

	if ( m_pBeam )
		{
			GetAttachment( 4, posGun, angleGun );
			GetAttachment( 3, posGun, angleGun );
			UTIL_Sparks( posGun );
			Vector vecEnd = (gpGlobals->v_forward * 5) + posGun;
			UTIL_TraceLine( posGun, vecEnd, dont_ignore_monsters, edict(), &tr );

			m_pBeam->EntsInit( entindex(), entindex() );
			m_pBeam->SetColor( 24, 121, 239 );
			m_pBeam->SetBrightness( 190 );
			m_pBeam->SetScrollRate( 20 );
			m_pBeam->SetStartAttachment( 4 );
			m_pBeam->SetEndAttachment( 3 );
			m_pBeam->DoSparks( tr.vecEndPos, posGun );
			m_pBeam->SetFlags( BEAM_FSHADEIN );
			m_pBeam->pev->spawnflags = SF_BEAM_SPARKSTART | SF_BEAM_TEMPORARY;
			UTIL_Sparks( tr.vecEndPos );
		}
	return;
}

void CTorch :: KillGas( void )
{
	if ( m_pBeam )
	{
		UTIL_Remove( m_pBeam );
		m_pBeam = NULL;
	}
	return;
}

#define MEDIC_CLIP_SIZE 17
#define MEDIC_CLIP_SIZE_EAGLE 7

#define MEDIC_EAGLE 1 << 0
#define MEDIC_HANDGUN 1 << 1
#define MEDIC_NEEDLE 1 << 2

// Weapon group
#define MEDIC_GUN_GROUP					3
#define MEDIC_GUN_EAGLE					0
#define MEDIC_GUN_PISTOL				1
#define MEDIC_GUN_NEEDLE				2
#define MEDIC_GUN_NONE					3

// Head group
#define MEDIC_HEAD_GROUP					2
enum {
	MEDIC_HEAD_WHITE,
	MEDIC_HEAD_BLACK,
	MEDIC_HEAD_COUNT
};

//=========================================================
// Medic specific animation events
//=========================================================
#define		MEDIC_AE_HIDEGUN		( 15)
#define		MEDIC_AE_SHOWNEEDLE		( 16)
#define		MEDIC_AE_HIDENEEDLE		( 17)
#define		MEDIC_AE_SHOWGUN		( 18)

enum
{
	TASK_MEDIC_SAY_HEAL = LAST_HGRUNT_ALLY_TASK + 1,
	TASK_MEDIC_HEAL,
};

Task_t	tlMedicHeal[] =
{
	{ TASK_MOVE_TO_TARGET_RANGE,			(float)50		},	// Move within 50 of target ent (client)
	{ TASK_FACE_IDEAL,						(float)0		},
	{ TASK_MEDIC_SAY_HEAL,					(float)0		},
	{ TASK_PLAY_SEQUENCE_FACE_TARGET,		(float)ACT_ARM	},			// Whip out the needle
	{ TASK_MEDIC_HEAL,						(float)0	},	// Put it in the player
	{ TASK_PLAY_SEQUENCE_FACE_TARGET,		(float)ACT_DISARM	},			// Put away the needle
};

Schedule_t	slMedicHeal[] =
{
	{
		tlMedicHeal,
		ARRAYSIZE ( tlMedicHeal ),
		0,	// Don't interrupt or he'll end up running around with a needle all the time
		0,
		"Heal"
	},
};

Task_t	tlMedicDrawGun[] =
{
	{ TASK_PLAY_SEQUENCE,		(float)ACT_DISARM	},			// Put away the needle
};

Schedule_t	slMedicDrawGun[] =
{
	{
		tlMedicDrawGun,
		ARRAYSIZE ( tlMedicDrawGun ),
		0,	// Don't interrupt or he'll end up running around with a needle all the time
		0,
		"DrawGun"
	},
};

LINK_ENTITY_TO_CLASS( monster_human_medic_ally, CMedic )

TYPEDESCRIPTION	CMedic::m_SaveData[] =
{
	DEFINE_FIELD( CMedic, m_flHealCharge, FIELD_FLOAT ),
	DEFINE_FIELD( CMedic, m_fDepleteLine, FIELD_BOOLEAN ),
	DEFINE_FIELD( CMedic, m_fHealing, FIELD_BOOLEAN ),
};

IMPLEMENT_SAVERESTORE( CMedic, CHFGrunt )

DEFINE_CUSTOM_SCHEDULES( CMedic )
{
	slMedicHeal,
	slMedicDrawGun,
};

IMPLEMENT_CUSTOM_SCHEDULES( CMedic, CHFGrunt )

bool CMedic::Heal( void )
{
	if ( !HasHealCharge() || !HasHealTarget() )
		return false;

	Vector target = m_hTargetEnt->pev->origin - pev->origin;
	if ( target.Length() > 100 )
		return false;

	m_flHealCharge -= m_hTargetEnt->TakeHealth( Q_min(10, m_flHealCharge), DMG_GENERIC );
	ALERT(at_aiconsole, "Medic grunt heal charge left: %f\n", m_flHealCharge);
	m_fHealing = TRUE;
	return true;
}

void CMedic::StartTask(Task_t *pTask)
{
	switch( pTask->iTask )
	{
	case TASK_MEDIC_HEAL:
		m_IdealActivity = ACT_MELEE_ATTACK2;
		if (Heal())
			EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "fgrunt/medic_give_shot.wav", 1, ATTN_NORM );
		break;
	case TASK_MEDIC_SAY_HEAL:
		m_hTalkTarget = m_hTargetEnt;
		PlaySentence( "MG_HEAL", 2, VOL_NORM, ATTN_IDLE );
		TaskComplete();
		break;
	default:
		CHFGrunt::StartTask(pTask);
		break;
	}
}

void CMedic::RunTask(Task_t *pTask)
{
	switch ( pTask->iTask )
	{
	case TASK_MEDIC_HEAL:
		if ( m_fSequenceFinished )
		{
			if (HasHealTarget() && CheckHealCharge()) {
				m_IdealActivity = ACT_MELEE_ATTACK2;
				ALERT(at_aiconsole, "Medic continuing healing\n");
				Heal();
			} else {
				TaskComplete();
				StopHealing();
			}
		}
		else
		{
			if ( TargetDistance() > 90 ) {
				TaskComplete();
				StopHealing();
			}
			if (m_hTargetEnt != 0)
			{
				pev->ideal_yaw = UTIL_VecToYaw( m_hTargetEnt->pev->origin - pev->origin );
				ChangeYaw( pev->yaw_speed );
			}
		}
		break;
	default:
		CHFGrunt::RunTask(pTask);
		break;
	}
}

Schedule_t *CMedic::GetSchedule()
{
	if (m_fHealing) {
		StopHealing();
	}

	Schedule_t* prioritizedSchedule = PrioritizedSchedule();
	if (prioritizedSchedule)
		return prioritizedSchedule;
	if ( FBitSet( pev->weapons, MEDIC_EAGLE|MEDIC_HANDGUN ) &&
		 (GetBodygroup(MEDIC_GUN_GROUP) == MEDIC_GUN_NEEDLE || GetBodygroup(MEDIC_GUN_GROUP) == MEDIC_GUN_NONE)) {
		return slMedicDrawGun;
	}
	switch( m_MonsterState )
	{
	case MONSTERSTATE_IDLE:
	case MONSTERSTATE_ALERT:
		if ( m_hEnemy == 0 )
		{
			if (m_hTargetEnt != 0 && m_hTargetEnt->IsPlayer())
			{
				if ( TargetDistance() <= 128 )
				{
					if ( CheckHealCharge() && m_hTargetEnt->pev->health <= m_hTargetEnt->pev->max_health * 0.75 ) {
						ALERT(at_aiconsole, "Medic is going to heal a player\n");
						return GetScheduleOfType(SCHED_MEDIC_HEAL);
					}
				}
			}
			// was called by other ally
			else if (HasHealCharge() && HasHealTarget()) {
				return GetScheduleOfType(SCHED_MEDIC_HEAL);
			}
		}
	}
	return CHFGrunt::GetSchedule();
}

Schedule_t *CMedic::GetScheduleOfType(int Type)
{
	switch (Type) {
	case SCHED_MEDIC_HEAL:
		return slMedicHeal;
	default:
		return CHFGrunt::GetScheduleOfType(Type);
	}
}

void CMedic::StopFollowing(BOOL clearSchedule)
{
	if (InHealSchedule() && (m_hTargetEnt != 0 && !m_hTargetEnt->IsPlayer()))
		clearSchedule = FALSE;
	CHFGrunt::StopFollowing(clearSchedule);
}

void CMedic::SetAnswerQuestion(CTalkMonster *pSpeaker)
{
	if (!m_fHealing) {
		CTalkMonster::SetAnswerQuestion(pSpeaker);
	}
}

void CMedic::Spawn()
{
	Precache( );

	SpawnHelper("models/hgrunt_medic.mdl", gSkillData.medicHealth);

	if (!pev->weapons)
	{
		pev->weapons |= MEDIC_EAGLE; // some medics on existing maps don't have a weapon selected
	}
	m_cClipSize = MEDIC_CLIP_SIZE_EAGLE;
	if ( FBitSet( pev->weapons, MEDIC_EAGLE ) )
	{
		SetBodygroup( MEDIC_GUN_GROUP, MEDIC_GUN_EAGLE );
	}
	else if ( FBitSet( pev->weapons, MEDIC_HANDGUN ) )
	{
		SetBodygroup( MEDIC_GUN_GROUP, MEDIC_GUN_PISTOL );
		m_cClipSize = MEDIC_CLIP_SIZE;
	}
	else if ( FBitSet( pev->weapons, MEDIC_NEEDLE ) )
	{
		SetBodygroup( MEDIC_GUN_GROUP, MEDIC_GUN_NEEDLE );
	}
	m_cAmmoLoaded		= m_cClipSize;

	if (m_iHead < 0 || m_iHead >= MEDIC_HEAD_COUNT) {
		m_iHead = RANDOM_LONG(MEDIC_HEAD_WHITE, MEDIC_HEAD_BLACK);
	}

	SetBodygroup(MEDIC_HEAD_GROUP, m_iHead);

	m_flHealCharge = gSkillData.medicHeal;
	MonsterInit();
	SetUse( &CTalkMonster::FollowerUse );
}

void CMedic::Precache()
{
	PRECACHE_MODEL("models/hgrunt_medic.mdl");
	PRECACHE_SOUND("weapons/desert_eagle_fire.wav");
	PRECACHE_SOUND("weapons/desert_eagle_reload.wav");
	PRECACHE_SOUND("weapons/pl_gun3.wav");
	PRECACHE_SOUND("fgrunt/medic_give_shot.wav");
	PRECACHE_SOUND("fgrunt/medical.wav");
	PrecacheHelper();
	TalkInit();
	if (m_iHead == MEDIC_HEAD_BLACK)
		m_voicePitch = 95;
	else
		m_voicePitch = 105;
	CTalkMonster::Precache();
}

void CMedic::HandleAnimEvent(MonsterEvent_t *pEvent)
{
	switch ( pEvent->event )
	{
	case MEDIC_AE_SHOWNEEDLE:
		SetBodygroup( MEDIC_GUN_GROUP, MEDIC_GUN_NEEDLE );
		break;

	case MEDIC_AE_SHOWGUN:
		if ( FBitSet( pev->weapons, MEDIC_EAGLE ) )
			SetBodygroup( MEDIC_GUN_GROUP, MEDIC_GUN_EAGLE );
		else if ( FBitSet( pev->weapons, MEDIC_HANDGUN ) )
			SetBodygroup( MEDIC_GUN_GROUP, MEDIC_GUN_PISTOL );
		else
			SetBodygroup( MEDIC_GUN_GROUP, MEDIC_GUN_NEEDLE );
		break;

	case MEDIC_AE_HIDENEEDLE:
		SetBodygroup( MEDIC_GUN_GROUP, MEDIC_GUN_NONE );
		break;
	case MEDIC_AE_HIDEGUN:
		SetBodygroup( MEDIC_GUN_GROUP, MEDIC_GUN_NONE );
		break;

	case HGRUNT_ALLY_AE_DROP_GUN:
		if ( FBitSet( pev->weapons, MEDIC_EAGLE | MEDIC_HANDGUN ) )
		{
			DropMyItems(FALSE);
		}
		break;
	case HGRUNT_ALLY_AE_RELOAD:
		EMIT_SOUND( ENT(pev), CHAN_WEAPON, "weapons/desert_eagle_reload.wav", 1, ATTN_NORM );
		m_cAmmoLoaded = m_cClipSize;
		ClearConditions(bits_COND_NO_AMMO_LOADED);
		break;
	case HGRUNT_ALLY_AE_BURST1:
	{
		if (FBitSet(pev->weapons, MEDIC_EAGLE)) {
			FirePistol("weapons/desert_eagle_fire.wav", BULLET_MONSTER_357);
		} else if (FBitSet(pev->weapons, MEDIC_HANDGUN)) {
			FirePistol("weapons/pl_gun3.wav", BULLET_MONSTER_9MM);
		}
	}
		break;
	case HGRUNT_ALLY_AE_BURST2:
	case HGRUNT_ALLY_AE_BURST3:
		break;
	case HGRUNT_ALLY_AE_KICK:
	{
		KickImpl(gSkillData.medicDmgKick);
	}
	break;
	default:
		CHFGrunt::HandleAnimEvent(pEvent);
		break;
	}
}

BOOL CMedic::CheckRangeAttack1(float flDot, float flDist)
{
	return FBitSet( pev->weapons, MEDIC_EAGLE | MEDIC_HANDGUN ) && CHFGrunt::CheckRangeAttack1(flDot, flDist);
}

BOOL CMedic::CheckRangeAttack2(float flDot, float flDist)
{
	return FALSE;
}

void CMedic::GibMonster()
{
	if ( FBitSet( pev->weapons, MEDIC_EAGLE | MEDIC_HANDGUN ) && GetBodygroup(MEDIC_GUN_GROUP) != MEDIC_GUN_NONE )
	{// throw a gun if the grunt has one
		DropMyItems(TRUE);
	}
	CTalkMonster::GibMonster();
}

void CMedic::DropMyItems(BOOL isGibbed)
{
	if (!isGibbed) {
		SetBodygroup( MEDIC_GUN_GROUP, MEDIC_GUN_NONE );
	}
	Vector	vecGunPos;
	Vector	vecGunAngles;
	GetAttachment( 0, vecGunPos, vecGunAngles );
	if (FBitSet(pev->weapons, MEDIC_EAGLE))
		DropMyItem("weapon_eagle", vecGunPos, vecGunAngles, isGibbed);
	else if (FBitSet(pev->weapons, MEDIC_HANDGUN)) {
		DropMyItem("weapon_9mmhandgun", vecGunPos, vecGunAngles, isGibbed);
	}
}

void CMedic::FirePistol(const char *shotSound , Bullet bullet)
{
	UTIL_MakeVectors( pev->angles );
	Vector vecShootOrigin = GetGunPosition();
	Vector vecShootDir = ShootAtEnemy( vecShootOrigin );

	Vector angDir = UTIL_VecToAngles( vecShootDir );
	SetBlending( 0, angDir.x );
	pev->effects = EF_MUZZLEFLASH;

	FireBullets( 1, vecShootOrigin, vecShootDir, VECTOR_CONE_2DEGREES, 1024, bullet );

	int pitchShift = RANDOM_LONG( 0, 20 );
	// Only shift about half the time
	if( pitchShift > 10 )
		pitchShift = 0;
	else
		pitchShift -= 5;
	EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, shotSound, 1, ATTN_NORM, 0, 100 + pitchShift );
	CSoundEnt::InsertSound ( bits_SOUND_COMBAT, pev->origin, 384, 0.3 );

	m_cAmmoLoaded--;// take away a bullet!
}

void CMedic::StartFollowingHealTarget(CBaseEntity *pTarget)
{
	if( m_pCine )
		m_pCine->CancelScript();

	if( m_hEnemy != 0 )
		m_IdealMonsterState = MONSTERSTATE_ALERT;

	m_hTargetEnt = pTarget;
	ClearConditions( bits_COND_CLIENT_PUSH );
	ClearSchedule();
	ChangeSchedule(GetScheduleOfType(SCHED_MEDIC_HEAL));
	ALERT(at_aiconsole, "Medic started to follow injured %s\n", STRING(pTarget->pev->classname));
}

void CMedic::StopHealing()
{
	m_fHealing = FALSE;
	EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "common/null.wav", 1, ATTN_NORM );
	if (m_hTargetEnt != 0 && !m_hTargetEnt->IsPlayer()) {
		if(m_movementGoal & MOVEGOAL_TARGETENT)
			RouteClear(); // Stop him from walking toward the player
		m_hTargetEnt = 0;
		if( m_hEnemy != 0 )
			m_IdealMonsterState = MONSTERSTATE_COMBAT;
	}
}

CBaseEntity* CMedic::HealTarget()
{
	if (m_hTargetEnt != 0 && m_hTargetEnt->IsAlive() && (m_hTargetEnt->pev->health < m_hTargetEnt->pev->max_health) &&
			((m_hTargetEnt->MyMonsterPointer() && IRelationship(m_hTargetEnt) < R_DL) || m_hTargetEnt->IsPlayer())) {
		return m_hTargetEnt;
	}
	return 0;
}

bool CMedic::CheckHealCharge()
{
	if ( !HasHealCharge() )
	{
		if ( !m_fDepleteLine )
		{
			PlaySentence( "MG_NOTHEAL", 2, VOL_NORM, ATTN_IDLE );
			m_fDepleteLine = TRUE;
		}
		return false;
	}
	return true;
}

bool CMedic::ReadyToHeal()
{
	if( m_MonsterState == MONSTERSTATE_SCRIPT )
	{
		if( !m_pCine )
			return false;
		if( !m_pCine->CanInterrupt() )
			return false;
	}

	if( !IsAlive() )
		return false;

	return HasHealCharge() && !InHealSchedule();
}

bool CMedic::InHealSchedule()
{
	return m_pSchedule == slMedicHeal;
}