//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//=============================================================================//

#include "cbase.h"
#include "npcevent.h"
#include "in_buttons.h"
//Nightfall - amckern - used for HUD FragTimer
#include "hl2_player_shared.h"
#ifdef CLIENT_DLL
#include "c_hl2mp_player.h"
#include "c_te_effect_dispatch.h"
#else
#include "hl2mp_player.h"
#include "te_effect_dispatch.h"
#include "grenade_frag.h"
#endif

#include "weapon_ar2.h"
#include "effect_dispatch_data.h"
#include "weapon_hl2mpbasehlmpcombatweapon.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

#define GRENADE_TIMER 2.5f //Seconds

#define GRENADE_PAUSED_NO 0
#define GRENADE_PAUSED_PRIMARY 1
#define GRENADE_PAUSED_SECONDARY 2


//Nightfall - amckern - for cookoff sounds...
#define GRENADE_BLIP_FREQUENCY 1.0f
#define GRENADE_BLIP_FAST_FREQUENCY 0.3f


#define GRENADE_RADIUS 4.0f // inches

#define GRENADE_DAMAGE_RADIUS 250.0f

#ifdef CLIENT_DLL
#define CWeaponFrag C_WeaponFrag
#endif

//-----------------------------------------------------------------------------
// Fragmentation grenades
//-----------------------------------------------------------------------------
class CWeaponFrag: public CBaseHL2MPCombatWeapon
{
	DECLARE_CLASS( CWeaponFrag, CBaseHL2MPCombatWeapon );
public:

	DECLARE_NETWORKCLASS(); 
	DECLARE_PREDICTABLE();

	CWeaponFrag();

	void	Precache( void );
	void	PrimaryAttack( void );
	void	SecondaryAttack( void );
	void	DecrementAmmo( CBaseCombatCharacter *pOwner );
	void	ItemPostFrame( void );

	bool	Deploy( void );
	bool	Holster( CBaseCombatWeapon *pSwitchingTo = NULL );
	
	bool	Reload( void );

#ifndef CLIENT_DLL
	void Operator_HandleAnimEvent( animevent_t *pEvent, CBaseCombatCharacter *pOperator );
#endif

 void ThrowGrenade( CBasePlayer *pPlayer );
bool IsPrimed( bool ) { return ( m_AttackPaused != 0 ); }
// MARKC -- I had to add these three so that DropPrimedFragGrenade could access some
// of the private vars. DropPrimedFragGrenade is a function that is executed by
// CHL2MP_Player::Weapon_Drop from dlls\hl2mp_dll\hl2mp_player.cpp
bool IsCooking() { return ( m_bIsCooking ); }
float getCookTimer() { return ( m_flCookOffTimer ); }
void setCookTimer(float fVal) { m_flCookOffTimer = fVal; }

private:
	void RollGrenade( CBasePlayer *pPlayer );
	void LobGrenade( CBasePlayer *pPlayer );
	// check a throw from vecSrc. If not valid, move the position back along the line to vecEye
	void CheckThrowPosition( CBasePlayer *pPlayer, const Vector &vecEye, Vector &vecSrc );
	
	CNetworkVar( bool, m_bRedraw ); //Draw the weapon again after throwing a grenade
	
	CNetworkVar( int, m_AttackPaused );
	CNetworkVar( bool, m_fDrawbackFinished );
	
	//Nightfall - amckern - cookoff!
	CNetworkVar( float, m_flCookOffTimer );
	CNetworkVar( bool, m_bIsCooking );
	CNetworkVar( float, m_flNextBlipTime );
	
	void UpdateFragTimer( void );
	
	CWeaponFrag( const CWeaponFrag & );

#ifndef CLIENT_DLL
	DECLARE_ACTTABLE();
#endif
};

#ifndef CLIENT_DLL

acttable_t	CWeaponFrag::m_acttable[] = 
{
	{ ACT_HL2MP_IDLE,					ACT_HL2MP_IDLE_GRENADE,					false },
	{ ACT_HL2MP_RUN,					ACT_HL2MP_RUN_GRENADE,					false },
	{ ACT_HL2MP_IDLE_CROUCH,			ACT_HL2MP_IDLE_CROUCH_GRENADE,			false },
	{ ACT_HL2MP_WALK_CROUCH,			ACT_HL2MP_WALK_CROUCH_GRENADE,			false },
	{ ACT_HL2MP_GESTURE_RANGE_ATTACK,	ACT_HL2MP_GESTURE_RANGE_ATTACK_GRENADE,	false },
	{ ACT_HL2MP_GESTURE_RELOAD,			ACT_HL2MP_GESTURE_RELOAD_GRENADE,		false },
	{ ACT_HL2MP_JUMP,					ACT_HL2MP_JUMP_GRENADE,					false },
};

IMPLEMENT_ACTTABLE(CWeaponFrag);

#endif

IMPLEMENT_NETWORKCLASS_ALIASED( WeaponFrag, DT_WeaponFrag )

BEGIN_NETWORK_TABLE( CWeaponFrag, DT_WeaponFrag )

#ifdef CLIENT_DLL
RecvPropBool( RECVINFO( m_bRedraw ) ),
RecvPropBool( RECVINFO( m_fDrawbackFinished ) ),
RecvPropInt( RECVINFO( m_AttackPaused ) ),
RecvPropTime( RECVINFO( m_flCookOffTimer ) ),
RecvPropTime( RECVINFO( m_flNextBlipTime ) ),
RecvPropBool( RECVINFO( m_bIsCooking ) ),

#else
SendPropBool( SENDINFO( m_bRedraw ) ),
SendPropBool( SENDINFO( m_fDrawbackFinished ) ),
SendPropInt( SENDINFO( m_AttackPaused ) ),
SendPropTime( SENDINFO( m_flCookOffTimer ) ),
SendPropTime( SENDINFO( m_flNextBlipTime ) ),
SendPropBool( SENDINFO( m_bIsCooking ) ),
#endif

END_NETWORK_TABLE()

BEGIN_PREDICTION_DATA( CWeaponFrag )
DEFINE_PRED_FIELD( m_bRedraw, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_fDrawbackFinished, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_AttackPaused, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_flCookOffTimer, FIELD_TIME, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_flNextBlipTime, FIELD_TIME, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_bIsCooking, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
END_PREDICTION_DATA()

LINK_ENTITY_TO_CLASS( weapon_frag, CWeaponFrag );
PRECACHE_WEAPON_REGISTER(weapon_frag);

CWeaponFrag::CWeaponFrag( void )
{

}
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CWeaponFrag::Precache( void )
{
	BaseClass::Precache();

#ifndef CLIENT_DLL
	UTIL_PrecacheOther( "npc_grenade_frag" );
#endif

	PrecacheScriptSound( "WeaponFrag.Throw" );
	PrecacheScriptSound( "WeaponFrag.Roll" );

	m_bRedraw = false;
}

#ifndef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pEvent - 
//			*pOperator - 
//-----------------------------------------------------------------------------
void CWeaponFrag::Operator_HandleAnimEvent( animevent_t *pEvent, CBaseCombatCharacter *pOperator )
{
	CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
	bool fThrewGrenade = false;

	switch( pEvent->event )
	{
		case EVENT_WEAPON_SEQUENCE_FINISHED:
			m_fDrawbackFinished = true;
			break;

		case EVENT_WEAPON_THROW:
			ThrowGrenade( pOwner );
			DecrementAmmo( pOwner );
			fThrewGrenade = true;
			break;

		case EVENT_WEAPON_THROW2:
			RollGrenade( pOwner );
			DecrementAmmo( pOwner );
			fThrewGrenade = true;
			break;

		case EVENT_WEAPON_THROW3:
			LobGrenade( pOwner );
			DecrementAmmo( pOwner );
			fThrewGrenade = true;
			break;

		default:
			BaseClass::Operator_HandleAnimEvent( pEvent, pOperator );
			break;
	}

#define RETHROW_DELAY	0.5
	if( fThrewGrenade )
	{
		m_flNextPrimaryAttack	= gpGlobals->curtime + RETHROW_DELAY;
		m_flNextSecondaryAttack	= gpGlobals->curtime + RETHROW_DELAY;
		m_flTimeWeaponIdle = FLT_MAX; //NOTE: This is set once the animation has finished up!
	}
}

#endif

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CWeaponFrag::Deploy( void )
{
	m_bRedraw = false;
	m_fDrawbackFinished = false;
	
	//Nightfall - amckern - unset cookoff...
	m_bIsCooking = false;
	UpdateFragTimer();
	
	return BaseClass::Deploy();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CWeaponFrag::Holster( CBaseCombatWeapon *pSwitchingTo )
{
	m_bRedraw = false;
	m_fDrawbackFinished = false;

	return BaseClass::Holster( pSwitchingTo );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CWeaponFrag::Reload( void )
{
	if ( !HasPrimaryAmmo() )
		return false;
	
	if ( ( m_bRedraw ) && ( m_flNextPrimaryAttack <= gpGlobals->curtime ) && ( m_flNextSecondaryAttack <= gpGlobals->curtime ) )
	{
		//Redraw the weapon
		SendWeaponAnim( ACT_VM_DRAW );
		
		//Update our times
		m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration();
		m_flNextSecondaryAttack = gpGlobals->curtime + SequenceDuration();
		m_flTimeWeaponIdle = gpGlobals->curtime + SequenceDuration();
		
		//Nightfall - amckern - unset cookoff...
		m_bIsCooking = false;
		
		//Mark this as done
		m_bRedraw = false;
		
		UpdateFragTimer();
	}
	
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CWeaponFrag::SecondaryAttack( void )
{
    if ( m_bRedraw )
		return;
	
	if ( m_bRedraw || m_fDrawbackFinished || m_bIsCooking ) //Nightfall - amckern - no secondary attack during cookoff
		return;

	if ( !HasPrimaryAmmo() )
		return;

	CBaseCombatCharacter *pOwner  = GetOwner();

	if ( pOwner == NULL )
		return;

	CBasePlayer *pPlayer = ToBasePlayer( pOwner );
	
	if ( pPlayer == NULL )
		return;

	// Note that this is a secondary attack and prepare the grenade attack to pause.
	m_AttackPaused = GRENADE_PAUSED_SECONDARY;
	SendWeaponAnim( ACT_VM_PULLBACK_LOW );

	// Don't let weapon idle interfere in the middle of a throw!
	m_flTimeWeaponIdle = FLT_MAX;
	m_flNextSecondaryAttack	= FLT_MAX;

	// If I'm now out of ammo, switch away
	if ( !HasPrimaryAmmo() )
	{
		pPlayer->SwitchToNextBestWeapon( this );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CWeaponFrag::PrimaryAttack( void )
{
	if ( m_bRedraw )
		return;

	CBaseCombatCharacter *pOwner  = GetOwner();
	
	if ( pOwner == NULL )
	{ 
		return;
	}
	
	if ( m_bRedraw || m_fDrawbackFinished || m_bIsCooking ) //Nightfall - amckern - no primary attack during cookoff
		return;

	CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );;

	if ( !pPlayer )
		return;

	// Note that this is a primary attack and prepare the grenade attack to pause.
	m_AttackPaused = GRENADE_PAUSED_PRIMARY;
	SendWeaponAnim( ACT_VM_PULLBACK_HIGH );
	
	// Put both of these off indefinitely. We do not know how long
	// the player will hold the grenade.
	m_flTimeWeaponIdle = FLT_MAX;
	m_flNextPrimaryAttack = FLT_MAX;

	// If I'm now out of ammo, switch away
	if ( !HasPrimaryAmmo() )
	{
		pPlayer->SwitchToNextBestWeapon( this );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pOwner - 
//-----------------------------------------------------------------------------
void CWeaponFrag::DecrementAmmo( CBaseCombatCharacter *pOwner )
{
	pOwner->RemoveAmmo( 1, m_iPrimaryAmmoType );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CWeaponFrag::ItemPostFrame( void )
{
if( m_fDrawbackFinished )
{
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );

if (pOwner)
{
switch( m_AttackPaused )
{
case GRENADE_PAUSED_PRIMARY:
if( !(pOwner->m_nButtons & IN_ATTACK) )
{
if (m_bIsCooking) {
// Button released? throw the frag and set the timer
if( gpGlobals->curtime > m_flCookOffTimer )
m_flCookOffTimer = 0;
else
m_flCookOffTimer = m_flCookOffTimer - gpGlobals->curtime;
}
SendWeaponAnim( ACT_VM_THROW );
m_fDrawbackFinished = false;
} else if ( (pOwner->m_nButtons & IN_ATTACK2) && ( pOwner->m_afButtonPressed & IN_ATTACK2 ) ) { // Tapping other key starts cookoff!
if (m_bIsCooking) {
// Player hit key while grenade cooking -- defuse frag
m_bIsCooking = false;
m_flCookOffTimer = gpGlobals->curtime;
WeaponSound( SPECIAL2 );
} else {
// Player hit key while grenade idle -- start cooking!
m_bIsCooking = true;
m_flCookOffTimer = gpGlobals->curtime + GRENADE_TIMER;
m_flNextBlipTime = gpGlobals->curtime + GRENADE_BLIP_FREQUENCY;
WeaponSound( RELOAD );
}
} else if (m_bIsCooking) {
if( gpGlobals->curtime > m_flCookOffTimer ) {
// Timer ran out? We set the timer to 0 and throw the frag
m_flCookOffTimer = 0;
SendWeaponAnim( ACT_VM_THROW );
m_fDrawbackFinished = false;
} else if( gpGlobals->curtime > m_flNextBlipTime ) {
// Play the chirp sound
if (m_flCookOffTimer - gpGlobals->curtime <= 1.5)
m_flNextBlipTime = gpGlobals->curtime + GRENADE_BLIP_FAST_FREQUENCY;
else
m_flNextBlipTime = gpGlobals->curtime + GRENADE_BLIP_FREQUENCY;
WeaponSound( RELOAD );
}
}
break;

case GRENADE_PAUSED_SECONDARY:
if( !(pOwner->m_nButtons & IN_ATTACK2) )
{
// Button released? throw the frag and set the timer
if (m_bIsCooking) {
if( gpGlobals->curtime > m_flCookOffTimer )
m_flCookOffTimer = 0;
else
m_flCookOffTimer = m_flCookOffTimer - gpGlobals->curtime;
}
//See if we're ducking
if ( pOwner->m_nButtons & IN_DUCK )
{
//Send the weapon animation
SendWeaponAnim( ACT_VM_SECONDARYATTACK );
}
else
{
//Send the weapon animation
SendWeaponAnim( ACT_VM_HAULBACK );
}

m_fDrawbackFinished = false;
} else if ( ( pOwner->m_nButtons & IN_ATTACK ) && ( pOwner->m_afButtonPressed & IN_ATTACK ) ){ // Reload key starts cookoff!
// Player hit key while grenade cooking -- defuse frag
if (m_bIsCooking) {
m_bIsCooking = false;
m_flCookOffTimer = gpGlobals->curtime;
WeaponSound( SPECIAL2 );
} else {
// Player hit key while grenade idle -- start cooking!
m_bIsCooking = true;
m_flCookOffTimer = gpGlobals->curtime + GRENADE_TIMER;
m_flNextBlipTime = gpGlobals->curtime + GRENADE_BLIP_FREQUENCY;
WeaponSound( RELOAD );
}
} else if (m_bIsCooking) {
if( gpGlobals->curtime > m_flCookOffTimer ) {
// Timer ran out? We set the timer to 0 and throw the frag
m_flCookOffTimer = 0;
SendWeaponAnim( ACT_VM_THROW );
m_fDrawbackFinished = false;
} else if( gpGlobals->curtime > m_flNextBlipTime ) {
// Play the chirp sound
if (m_flCookOffTimer - gpGlobals->curtime <= 1.5)
m_flNextBlipTime = gpGlobals->curtime + GRENADE_BLIP_FAST_FREQUENCY;
else
m_flNextBlipTime = gpGlobals->curtime + GRENADE_BLIP_FREQUENCY;
WeaponSound( RELOAD );
}
}
break;

default:
break;
}
}
}
UpdateFragTimer();

BaseClass::ItemPostFrame();

if ( m_bRedraw )
{
if ( IsViewModelSequenceFinished() )
{
Reload();
}
}
}

void DropPrimedFragGrenade( CHL2MP_Player *pPlayer, CBaseCombatWeapon *pGrenade )
{
	CWeaponFrag *pWeaponFrag = dynamic_cast<CWeaponFrag*>( pGrenade );
	if ( pWeaponFrag )
	{
		//Nightfall - amckern - if this frag is cooking, set the timer with the reduced fuse
		if (pWeaponFrag->IsCooking()) {
			if( gpGlobals->curtime > pWeaponFrag->getCookTimer() )
				pWeaponFrag->setCookTimer(0);
			else
				pWeaponFrag->setCookTimer(pWeaponFrag->getCookTimer() - gpGlobals->curtime);
		}
		pWeaponFrag->ThrowGrenade( pPlayer );
		pWeaponFrag->DecrementAmmo( pPlayer );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pPlayer - 
//-----------------------------------------------------------------------------
void CWeaponFrag::ThrowGrenade( CBasePlayer *pPlayer )
{
#ifndef CLIENT_DLL
	Vector vecEye = pPlayer->EyePosition();
	Vector vForward, vRight;
	
	pPlayer->EyeVectors( &vForward, &vRight, NULL );
	Vector vecSrc = vecEye + vForward * 18.0f + vRight * 8.0f;
	CheckThrowPosition( pPlayer, vecEye, vecSrc );
	// vForward[0] += 0.1f;
	vForward[2] += 0.1f;
	
	Vector vecThrow;
	pPlayer->GetVelocity( &vecThrow, NULL );
	vecThrow += vForward * 1200;
	
	CBaseGrenade *pGrenade = NULL;
	if (m_bIsCooking)
		pGrenade = Fraggrenade_Create( vecSrc, vec3_angle, vecThrow, AngularImpulse(600,random->RandomInt(-1200,1200),0), pPlayer, m_flCookOffTimer );
	else
		pGrenade = Fraggrenade_Create( vecSrc, vec3_angle, vecThrow, AngularImpulse(600,random->RandomInt(-1200,1200),0), pPlayer, GRENADE_TIMER );
	
	if ( pGrenade )

	{
		if ( pPlayer && pPlayer->m_lifeState != LIFE_ALIVE )
		{
			pPlayer->GetVelocity( &vecThrow, NULL );

			IPhysicsObject *pPhysicsObject = pGrenade->VPhysicsGetObject();
			if ( pPhysicsObject )
			{
				pPhysicsObject->SetVelocity( &vecThrow, NULL );
			}
		}
		
		pGrenade->SetDamage( GetHL2MPWpnData().m_iPlayerDamage );
		pGrenade->SetDamageRadius( GRENADE_DAMAGE_RADIUS );
	}
#endif

	m_bRedraw = true;

	WeaponSound( SINGLE );
	
	// player "shoot" animation
	pPlayer->SetAnimation( PLAYER_ATTACK1 );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pPlayer - 
//-----------------------------------------------------------------------------
void CWeaponFrag::LobGrenade( CBasePlayer *pPlayer )
{
#ifndef CLIENT_DLL
	Vector vecEye = pPlayer->EyePosition();
	Vector vForward, vRight;
	
	pPlayer->EyeVectors( &vForward, &vRight, NULL );
	Vector vecSrc = vecEye + vForward * 18.0f + vRight * 8.0f + Vector( 0, 0, -8 );
	CheckThrowPosition( pPlayer, vecEye, vecSrc );
	
	Vector vecThrow;
	pPlayer->GetVelocity( &vecThrow, NULL );
	vecThrow += vForward * 350 + Vector( 0, 0, 50 );
	CBaseGrenade *pGrenade = NULL;
	if (m_bIsCooking)
		pGrenade = Fraggrenade_Create( vecSrc, vec3_angle, vecThrow, AngularImpulse(200,random->RandomInt(-600,600),0), pPlayer, m_flCookOffTimer );
	else
		pGrenade = Fraggrenade_Create( vecSrc, vec3_angle, vecThrow, AngularImpulse(200,random->RandomInt(-600,600),0), pPlayer, GRENADE_TIMER );
	
	if ( pGrenade )
	{
		pGrenade->SetDamage( GetHL2MPWpnData().m_iPlayerDamage );
		pGrenade->SetDamageRadius( GRENADE_DAMAGE_RADIUS );
	}
#endif

	WeaponSound( WPN_DOUBLE );

	// player "shoot" animation
	pPlayer->SetAnimation( PLAYER_ATTACK1 );

	m_bRedraw = true;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pPlayer - 
//-----------------------------------------------------------------------------
void CWeaponFrag::RollGrenade( CBasePlayer *pPlayer )
{
#ifndef CLIENT_DLL
	// BUGBUG: Hardcoded grenade width of 4 - better not change the model :)
	Vector vecSrc;
	pPlayer->CollisionProp()->NormalizedToWorldSpace( Vector( 0.5f, 0.5f, 0.0f ), &vecSrc );
	vecSrc.z += GRENADE_RADIUS;
	
	Vector vecFacing = pPlayer->BodyDirection2D( );
	// no up/down direction
	vecFacing.z = 0;
	VectorNormalize( vecFacing );
	trace_t tr;
	UTIL_TraceLine( vecSrc, vecSrc - Vector(0,0,16), MASK_PLAYERSOLID, pPlayer, COLLISION_GROUP_NONE, &tr );
	if ( tr.fraction != 1.0 )
	{
		// compute forward vec parallel to floor plane and roll grenade along that
		Vector tangent;
		CrossProduct( vecFacing, tr.plane.normal, tangent );
		CrossProduct( tr.plane.normal, tangent, vecFacing );
	}
	vecSrc += (vecFacing * 18.0);
	CheckThrowPosition( pPlayer, pPlayer->WorldSpaceCenter(), vecSrc );
	
	Vector vecThrow;
	pPlayer->GetVelocity( &vecThrow, NULL );
	vecThrow += vecFacing * 700;
	// put it on its side
	QAngle orientation(0,pPlayer->GetLocalAngles().y,-90);
	// roll it
	AngularImpulse rotSpeed(0,0,720);
	CBaseGrenade *pGrenade = NULL;
	if (m_bIsCooking)
		pGrenade = Fraggrenade_Create( vecSrc, orientation, vecThrow, rotSpeed, pPlayer, m_flCookOffTimer );
	else
		pGrenade = Fraggrenade_Create( vecSrc, orientation, vecThrow, rotSpeed, pPlayer, GRENADE_TIMER );
	
	if ( pGrenade )
	{
		pGrenade->SetDamage( GetHL2MPWpnData().m_iPlayerDamage );
		pGrenade->SetDamageRadius( GRENADE_DAMAGE_RADIUS );
	}

#endif

	WeaponSound( SPECIAL1 );

	// player "shoot" animation
	pPlayer->SetAnimation( PLAYER_ATTACK1 );

	m_bRedraw = true;
}

void CWeaponFrag::UpdateFragTimer( void ) {
	CHL2_Player *pPlayer = assert_cast<CHL2_Player*>( GetOwner() );
	if (m_bIsCooking && m_fDrawbackFinished)
		pPlayer->UpdateFragTimer(1.0f - (((float)m_flCookOffTimer - (float)gpGlobals->curtime) / (float)GRENADE_TIMER));
	else
		pPlayer->UpdateFragTimer( -1 );
}