source-engine/game/client/dod/c_dod_player.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//===========================================================================//

#include "cbase.h"
#include "c_dod_player.h"
#include "c_user_message_register.h"
#include "view.h"
#include "iclientvehicle.h"
#include "ivieweffects.h"
#include "input.h"
#include "IEffects.h"
#include "fx.h"
#include "c_basetempentity.h"
#include "hud_macros.h"
#include "engine/ivdebugoverlay.h"
#include "smoke_fog_overlay.h"
#include "bone_setup.h"
#include "in_buttons.h"
#include "r_efx.h"
#include "dlight.h"
#include "shake.h"
#include "cl_animevent.h"
#include "fx_dod_blood.h"
#include "effect_dispatch_data.h"	//for water ripple / splash effect
#include "c_te_effect_dispatch.h"	//ditto
#include "dod_gamerules.h"
#include <igameevents.h>
#include "physpropclientside.h"
#include "obstacle_pushaway.h"
#include "prediction.h"
#include "viewangleanim.h"
#include "soundenvelope.h"
#include "weapon_dodbipodgun.h"
#include "c_dod_basegrenade.h"
#include "dod_weapon_parse.h"
#include "view_scene.h"
#include "dod_headiconmanager.h"
#include "c_world.h"
#include "c_dod_bombtarget.h"
#include "toolframework/itoolframework.h"
#include "toolframework_client.h"
#include "c_team.h"
#include "collisionutils.h"
#include "weapon_dodsniper.h"
// NVNT - haptics system for spectating and grenades
#include "haptics/haptic_utils.h"
// NVNT - for grenade effects
#include "weapon_dodbasegrenade.h"
// NVNT - for planting bomb effect
#include "weapon_dodbasebomb.h"

#if defined( CDODPlayer )
	#undef CDODPlayer
#endif

#include "iviewrender_beams.h"			// flashlight beam

#include "materialsystem/imesh.h"		//for materials->FindMaterial
#include "iviewrender.h"				//for view->
ConVar cl_ragdoll_physics_enable( "cl_ragdoll_physics_enable", "1", 0, "Enable/disable ragdoll physics." );

ConVar cl_autoreload( "cl_autoreload", "1", FCVAR_USERINFO | FCVAR_ARCHIVE, "Set to 1 to auto reload your weapon when it is empty" );
ConVar cl_autorezoom( "cl_autorezoom", "1", FCVAR_USERINFO | FCVAR_ARCHIVE, "When set to 1, sniper rifles and bazooka weapons will automatically raise after each shot" );

#include "tier0/memdbgon.h"

//======================================================
//
// Cold Breath Emitter - for DOD players.
//
class ColdBreathEmitter : public CSimpleEmitter
{
public:
	
	ColdBreathEmitter( const char *pDebugName ) : CSimpleEmitter( pDebugName ) {}

	static ColdBreathEmitter *Create( const char *pDebugName )
	{
		return new ColdBreathEmitter( pDebugName );
	}

	void UpdateVelocity( SimpleParticle *pParticle, float timeDelta )
	{
		// Float up when lifetime is half gone.
		pParticle->m_vecVelocity[2] -= ( 8.0f * timeDelta );


		// FIXME: optimize this....
		pParticle->m_vecVelocity *= ExponentialDecay( 0.9, 0.03, timeDelta );
	}

	virtual	float UpdateRoll( SimpleParticle *pParticle, float timeDelta )
	{
		pParticle->m_flRoll += pParticle->m_flRollDelta * timeDelta;
		
		pParticle->m_flRollDelta += pParticle->m_flRollDelta * ( timeDelta * -2.0f );

		//Cap the minimum roll
		if ( fabs( pParticle->m_flRollDelta ) < 0.5f )
		{
			pParticle->m_flRollDelta = ( pParticle->m_flRollDelta > 0.0f ) ? 0.5f : -0.5f;
		}

		return pParticle->m_flRoll;
	}

private:

	ColdBreathEmitter( const ColdBreathEmitter & );
};


void RecvProxy_StunTime( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
	C_DODPlayer *pPlayerData = (C_DODPlayer *) pStruct;

	if( pPlayerData != C_BasePlayer::GetLocalPlayer() )
		return;

	if ( (pPlayerData->m_flStunDuration != pData->m_Value.m_Float) && pData->m_Value.m_Float > 0 )
	{
		pPlayerData->m_flStunAlpha = 1;
	}

	pPlayerData->m_flStunDuration = pData->m_Value.m_Float;
	pPlayerData->m_flStunEffectTime = gpGlobals->curtime + pPlayerData->m_flStunDuration;
}

// -------------------------------------------------------------------------------- //
// Player animation event. Sent to the client when a player fires, jumps, reloads, etc..
// -------------------------------------------------------------------------------- //

class C_TEPlayerAnimEvent : public C_BaseTempEntity
{
public:
	DECLARE_CLASS( C_TEPlayerAnimEvent, C_BaseTempEntity );
	DECLARE_CLIENTCLASS();

	virtual void PostDataUpdate( DataUpdateType_t updateType )
	{
		// Create the effect.
		C_DODPlayer *pPlayer = dynamic_cast< C_DODPlayer* >( m_hPlayer.Get() );
		if ( pPlayer && !pPlayer->IsDormant() )
		{
			pPlayer->DoAnimationEvent( (PlayerAnimEvent_t)m_iEvent.Get(), m_nData );
		}	
	}

public:
	CNetworkHandle( CBasePlayer, m_hPlayer );
	CNetworkVar( int, m_iEvent );
	CNetworkVar( int, m_nData );
};

IMPLEMENT_CLIENTCLASS_EVENT( C_TEPlayerAnimEvent, DT_TEPlayerAnimEvent, CTEPlayerAnimEvent );


BEGIN_RECV_TABLE_NOBASE( C_TEPlayerAnimEvent, DT_TEPlayerAnimEvent )
	RecvPropEHandle( RECVINFO( m_hPlayer ) ),
	RecvPropInt( RECVINFO( m_iEvent ) ),
	RecvPropInt( RECVINFO( m_nData ) )
END_RECV_TABLE()

void RecvProxy_CapAreaIndex( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
	CDODPlayerShared *pShared = ( CDODPlayerShared *)pStruct;

	int iCapAreaIndex = pData->m_Value.m_Int;

	if ( iCapAreaIndex != pShared->GetCPIndex() )
	{
		pShared->SetCPIndex( iCapAreaIndex );
	}
}

// ------------------------------------------------------------------------------------------ //
// Data tables.
// ------------------------------------------------------------------------------------------ //

// CDODPlayerShared Data Tables
//=============================

// specific to the local player ( ideally should not be in CDODPlayerShared! )
BEGIN_RECV_TABLE_NOBASE( CDODPlayerShared, DT_DODSharedLocalPlayerExclusive )
	RecvPropInt( RECVINFO( m_iPlayerClass ) ),
	RecvPropInt( RECVINFO( m_iDesiredPlayerClass ) ),
	RecvPropFloat( RECVINFO( m_flDeployedYawLimitLeft ) ),
	RecvPropFloat( RECVINFO( m_flDeployedYawLimitRight ) ),
	RecvPropInt( RECVINFO( m_iCPIndex ), 0, RecvProxy_CapAreaIndex ),
	RecvPropArray3( RECVINFO_ARRAY( m_bPlayerDominated ), RecvPropBool( RECVINFO( m_bPlayerDominated[0] ) ) ),
	RecvPropArray3( RECVINFO_ARRAY( m_bPlayerDominatingMe ), RecvPropBool( RECVINFO( m_bPlayerDominatingMe[0] ) ) ),
END_RECV_TABLE()

// main table
BEGIN_RECV_TABLE_NOBASE( CDODPlayerShared, DT_DODPlayerShared )
	RecvPropFloat( RECVINFO( m_flStamina ) ),
	RecvPropTime( RECVINFO( m_flSlowedUntilTime ) ),
	RecvPropBool( RECVINFO( m_bProne ) ),
	RecvPropBool( RECVINFO( m_bIsSprinting ) ),
	RecvPropTime( RECVINFO( m_flGoProneTime ) ),
	RecvPropTime( RECVINFO( m_flUnProneTime ) ),
	RecvPropTime( RECVINFO( m_flDeployChangeTime ) ),
	RecvPropFloat( RECVINFO( m_flDeployedHeight ) ),
	RecvPropBool( RECVINFO( m_bPlanting ) ),
	RecvPropBool( RECVINFO( m_bDefusing ) ),
	RecvPropDataTable( "dodsharedlocaldata", 0, 0, &REFERENCE_RECV_TABLE(DT_DODSharedLocalPlayerExclusive) ),
END_RECV_TABLE()


// C_DODPlayer Data Tables
//=========================

// specific to the local player
BEGIN_RECV_TABLE_NOBASE( C_DODPlayer, DT_DODLocalPlayerExclusive )
	RecvPropVector( RECVINFO_NAME( m_vecNetworkOrigin, m_vecOrigin ) ),
	RecvPropFloat( RECVINFO( m_flStunDuration ), 0, RecvProxy_StunTime ),
	RecvPropFloat( RECVINFO( m_flStunMaxAlpha)),
	RecvPropInt( RECVINFO( m_iProgressBarDuration ) ),
	RecvPropFloat( RECVINFO( m_flProgressBarStartTime ) ),
END_RECV_TABLE()

// all players except the local player
BEGIN_RECV_TABLE_NOBASE( C_DODPlayer, DT_DODNonLocalPlayerExclusive )
	RecvPropVector( RECVINFO_NAME( m_vecNetworkOrigin, m_vecOrigin ) ),
END_RECV_TABLE()

// main table
IMPLEMENT_CLIENTCLASS_DT( C_DODPlayer, DT_DODPlayer, CDODPlayer )
	RecvPropDataTable( RECVINFO_DT( m_Shared ), 0, &REFERENCE_RECV_TABLE( DT_DODPlayerShared ) ),

	RecvPropDataTable( "dodlocaldata", 0, 0, &REFERENCE_RECV_TABLE(DT_DODLocalPlayerExclusive) ),
	RecvPropDataTable( "dodnonlocaldata", 0, 0, &REFERENCE_RECV_TABLE(DT_DODNonLocalPlayerExclusive) ),

	RecvPropFloat( RECVINFO( m_angEyeAngles[0] ) ),
	RecvPropFloat( RECVINFO( m_angEyeAngles[1] ) ),
	RecvPropEHandle( RECVINFO( m_hRagdoll ) ),
	RecvPropBool( RECVINFO( m_bSpawnInterpCounter ) ),
	RecvPropInt( RECVINFO( m_iAchievementAwardsMask ) ),

END_RECV_TABLE()


// ------------------------------------------------------------------------------------------ //
// Prediction tables.
// ------------------------------------------------------------------------------------------ //
BEGIN_PREDICTION_DATA_NO_BASE( CDODPlayerShared )
	DEFINE_PRED_FIELD( m_bProne, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
	DEFINE_PRED_FIELD( m_flStamina, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
	DEFINE_PRED_FIELD( m_bIsSprinting, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
	DEFINE_PRED_FIELD( m_flGoProneTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
	DEFINE_PRED_FIELD( m_flUnProneTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
	DEFINE_PRED_FIELD( m_flDeployChangeTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
	DEFINE_PRED_FIELD( m_flDeployedHeight, FIELD_FLOAT, FTYPEDESC_INSENDTABLE )
END_PREDICTION_DATA()

BEGIN_PREDICTION_DATA( C_DODPlayer )
	DEFINE_PRED_TYPEDESCRIPTION( m_Shared, CDODPlayerShared ),
	DEFINE_PRED_FIELD( m_flCycle, FIELD_FLOAT, FTYPEDESC_OVERRIDE | FTYPEDESC_PRIVATE | FTYPEDESC_NOERRORCHECK ),
	DEFINE_PRED_FIELD( m_nSequence, FIELD_INTEGER, FTYPEDESC_OVERRIDE | FTYPEDESC_PRIVATE | FTYPEDESC_NOERRORCHECK ),
END_PREDICTION_DATA()


// ----------------------------------------------------------------------------- //
// Client ragdoll entity.
// ----------------------------------------------------------------------------- //

ConVar cl_low_violence( "cl_low_violence", "0" );
ConVar cl_ragdoll_fade_time( "cl_ragdoll_fade_time", "15", FCVAR_CLIENTDLL );
ConVar cl_ragdoll_pronecheck_distance( "cl_ragdoll_pronecheck_distance", "64", FCVAR_GAMEDLL );

class C_DODRagdoll : public C_BaseAnimatingOverlay
{
public:
	DECLARE_CLASS( C_DODRagdoll, C_BaseAnimatingOverlay );
	DECLARE_CLIENTCLASS();
	
	C_DODRagdoll();
	~C_DODRagdoll();

	virtual void OnDataChanged( DataUpdateType_t type );

	int GetPlayerEntIndex() const;
	IRagdoll* GetIRagdoll() const;

	void ImpactTrace( trace_t *pTrace, int iDamageType, const char *pCustomImpactName );

	void ClientThink( void );
	void StartFadeOut( float fDelay );
	
	bool IsRagdollVisible();
private:
	
	C_DODRagdoll( const C_DODRagdoll & ) {}

	void Interp_Copy( C_BaseAnimatingOverlay *pSourceEntity );

	void CreateLowViolenceRagdoll();
	void CreateDODRagdoll();

private:

	EHANDLE	m_hPlayer;
	CNetworkVector( m_vecRagdollVelocity );
	CNetworkVector( m_vecRagdollOrigin );
	float m_fDeathTime;
	bool  m_bFadingOut;
};


IMPLEMENT_CLIENTCLASS_DT_NOBASE( C_DODRagdoll, DT_DODRagdoll, CDODRagdoll )
	RecvPropVector( RECVINFO(m_vecRagdollOrigin) ),
	RecvPropEHandle( RECVINFO( m_hPlayer ) ),
	RecvPropInt( RECVINFO( m_nModelIndex ) ),
	RecvPropInt( RECVINFO(m_nForceBone) ),
	RecvPropVector( RECVINFO(m_vecForce) ),
	RecvPropVector( RECVINFO( m_vecRagdollVelocity ) )
END_RECV_TABLE()


C_DODRagdoll::C_DODRagdoll()
{
	m_fDeathTime = -1;
	m_bFadingOut = false;
}

C_DODRagdoll::~C_DODRagdoll()
{
	PhysCleanupFrictionSounds( this );
}

void C_DODRagdoll::Interp_Copy( C_BaseAnimatingOverlay *pSourceEntity )
{
	if ( !pSourceEntity )
		return;
	
	VarMapping_t *pSrc = pSourceEntity->GetVarMapping();
	VarMapping_t *pDest = GetVarMapping();
    	
	// Find all the VarMapEntry_t's that represent the same variable.
	for ( int i = 0; i < pDest->m_Entries.Count(); i++ )
	{
		VarMapEntry_t *pDestEntry = &pDest->m_Entries[i];
		for ( int j=0; j < pSrc->m_Entries.Count(); j++ )
		{
			VarMapEntry_t *pSrcEntry = &pSrc->m_Entries[j];
			if ( !Q_strcmp( pSrcEntry->watcher->GetDebugName(),
				pDestEntry->watcher->GetDebugName() ) )
			{
				pDestEntry->watcher->Copy( pSrcEntry->watcher );
				break;
			}
		}
	}
}

void C_DODRagdoll::ImpactTrace( trace_t *pTrace, int iDamageType, const char *pCustomImpactName )
{
	IPhysicsObject *pPhysicsObject = VPhysicsGetObject();

	if( !pPhysicsObject )
		return;

	Vector dir = pTrace->endpos - pTrace->startpos;

	if ( iDamageType == DMG_BLAST )
	{
		dir *= 4000;  // adjust impact strength
				
		// apply force at object mass center
		pPhysicsObject->ApplyForceCenter( dir );
	}
	else
	{
		Vector hitpos;  
	
		VectorMA( pTrace->startpos, pTrace->fraction, dir, hitpos );
		VectorNormalize( dir );

		dir *= 4000;  // adjust impact strength

		// apply force where we hit it
		pPhysicsObject->ApplyForceOffset( dir, hitpos );	

		// Blood spray!
		FX_DOD_BloodSpray( hitpos, dir, 10 );
	}

	m_pRagdoll->ResetRagdollSleepAfterTime();
}


void C_DODRagdoll::CreateLowViolenceRagdoll()
{
	// Just play a death animation.
	// Find a death anim to play.
	int iMinDeathAnim = 9999, iMaxDeathAnim = -9999;
	for ( int iAnim=1; iAnim < 100; iAnim++ )
	{
		char str[512];
		Q_snprintf( str, sizeof( str ), "death%d", iAnim );
		if ( LookupSequence( str ) == -1 )
			break;
		
		iMinDeathAnim = MIN( iMinDeathAnim, iAnim );
		iMaxDeathAnim = MAX( iMaxDeathAnim, iAnim );
	}

	if ( iMinDeathAnim == 9999 )
	{
		CreateDODRagdoll();
	}
	else
	{
		int iDeathAnim = RandomInt( iMinDeathAnim, iMaxDeathAnim );
		char str[512];
		Q_snprintf( str, sizeof( str ), "death%d", iDeathAnim );

		SetSequence( LookupSequence( str ) );
		ForceClientSideAnimationOn();

		SetNetworkOrigin( m_vecRagdollOrigin );
		SetAbsOrigin( m_vecRagdollOrigin );
		SetAbsVelocity( m_vecRagdollVelocity );

		C_DODPlayer *pPlayer = dynamic_cast< C_DODPlayer* >( m_hPlayer.Get() );
		if ( pPlayer && !pPlayer->IsDormant() )
		{
			// move my current model instance to the ragdoll's so decals are preserved.
			pPlayer->SnatchModelInstance( this );

			SetAbsAngles( pPlayer->GetRenderAngles() );
			SetNetworkAngles( pPlayer->GetRenderAngles() );
		}
	
		Interp_Reset( GetVarMapping() );
	}
}

void C_DODRagdoll::CreateDODRagdoll()
{
	// First, initialize all our data. If we have the player's entity on our client,
	// then we can make ourselves start out exactly where the player is.
	C_DODPlayer *pPlayer = dynamic_cast< C_DODPlayer* >( m_hPlayer.Get() );

#ifdef _DEBUG
	DevMsg( 2, "CreateDODRagdoll %d %d\n", gpGlobals->framecount, pPlayer ? pPlayer->entindex() : 0 );
#endif
	
	if ( pPlayer && !pPlayer->IsDormant() )
	{
		// move my current model instance to the ragdoll's so decals are preserved.
		pPlayer->SnatchModelInstance( this );

		VarMapping_t *varMap = GetVarMapping();

		// Copy all the interpolated vars from the player entity.
		// The entity uses the interpolated history to get bone velocity.		
		if ( !pPlayer->IsLocalPlayer() && pPlayer->dod_IsInterpolationEnabled() )
		{
			Interp_Copy( pPlayer );

			SetAbsAngles( pPlayer->GetRenderAngles() );
			GetRotationInterpolator().Reset();

			m_flAnimTime = pPlayer->m_flAnimTime;
			SetSequence( pPlayer->GetSequence() );
			m_flPlaybackRate = pPlayer->GetPlaybackRate();
		}
		else
		{
			// This is the local player, so set them in a default
			// pose and slam their velocity, angles and origin
			SetAbsOrigin( m_vecRagdollOrigin );
			
			SetAbsAngles( pPlayer->GetRenderAngles() );

			SetAbsVelocity( m_vecRagdollVelocity );

			int iSeq = LookupSequence( "RagdollSpawn" );	// hax, find a neutral standing pose
			if ( iSeq == -1 )
			{
				Assert( false );	// missing look_idle?
				iSeq = 0;
			}
			
			SetSequence( iSeq );	// look_idle, basic pose
			SetCycle( 0.0 );

			Interp_Reset( varMap );
		}		

		m_nBody = pPlayer->GetBody();
	}
	else
	{
		// overwrite network origin so later interpolation will
		// use this position
		SetNetworkOrigin( m_vecRagdollOrigin );

		SetAbsOrigin( m_vecRagdollOrigin );
		SetAbsVelocity( m_vecRagdollVelocity );

		Interp_Reset( GetVarMapping() );
		
	}

	SetModelIndex( m_nModelIndex );
	
	// Turn it into a ragdoll.
	if ( cl_ragdoll_physics_enable.GetInt() )
	{
		// Make us a ragdoll..
		m_nRenderFX = kRenderFxRagdoll;

		matrix3x4_t boneDelta0[MAXSTUDIOBONES];
		matrix3x4_t boneDelta1[MAXSTUDIOBONES];
		matrix3x4_t currentBones[MAXSTUDIOBONES];
		const float boneDt = 0.05f;

		if ( pPlayer && pPlayer == C_BasePlayer::GetLocalPlayer() )
		{
			pPlayer->GetRagdollInitBoneArrays( boneDelta0, boneDelta1, currentBones, boneDt );
		}
		else
		{
			GetRagdollInitBoneArrays( boneDelta0, boneDelta1, currentBones, boneDt );
		}

		InitAsClientRagdoll( boneDelta0, boneDelta1, currentBones, boneDt );
	}
	else
	{
		ClientLeafSystem()->SetRenderGroup( GetRenderHandle(), RENDER_GROUP_TRANSLUCENT_ENTITY );
	}		

	// Fade out the ragdoll in a while
	StartFadeOut( cl_ragdoll_fade_time.GetFloat() );
	SetNextClientThink( gpGlobals->curtime + 5.0f );
}

void C_DODRagdoll::OnDataChanged( DataUpdateType_t type )
{
	BaseClass::OnDataChanged( type );

	if ( type == DATA_UPDATE_CREATED )
	{
		if ( cl_low_violence.GetInt() )
		{
			CreateLowViolenceRagdoll();
		}
		else
		{
			CreateDODRagdoll();
		}
	}
	else 
	{
		if ( !cl_ragdoll_physics_enable.GetInt() )
		{
			// Don't let it set us back to a ragdoll with data from the server.
			m_nRenderFX = kRenderFxNone;
		}
	}
}

IRagdoll* C_DODRagdoll::GetIRagdoll() const
{
	return m_pRagdoll;
}

bool C_DODRagdoll::IsRagdollVisible()
{
	Vector vMins = Vector(-1,-1,-1);	//WorldAlignMins();
	Vector vMaxs = Vector(1,1,1);	//WorldAlignMaxs();
		
	Vector origin = GetAbsOrigin();
	
	if( !engine->IsBoxInViewCluster( vMins + origin, vMaxs + origin) )
	{
		return false;
	}
	else if( engine->CullBox( vMins + origin, vMaxs + origin ) )
	{
		return false;
	}

	return true;
}

void C_DODRagdoll::ClientThink( void )
{
	SetNextClientThink( CLIENT_THINK_ALWAYS );

	if ( m_bFadingOut == true )
	{
		int iAlpha = GetRenderColor().a;
		int iFadeSpeed = 600.0f;

		iAlpha = MAX( iAlpha - ( iFadeSpeed * gpGlobals->frametime ), 0 );

		SetRenderMode( kRenderTransAlpha );
		SetRenderColorA( iAlpha );

		if ( iAlpha == 0 )
		{
			//Release();
			AddEffects( EF_NODRAW );
		}

		return;
	}

	for( int iClient = 1; iClient <= gpGlobals->maxClients; ++iClient )
	{
		C_DODPlayer *pEnt = static_cast< C_DODPlayer *> ( UTIL_PlayerByIndex( iClient ) );

		if(!pEnt || !pEnt->IsPlayer())
			continue;

		if ( m_hPlayer == NULL )
			continue;

		if ( pEnt->entindex() == m_hPlayer->entindex() )
			continue;
		
		if ( pEnt->GetHealth() <= 0 )
			continue;

		if ( pEnt->m_Shared.IsProne() == false )
			continue;

		Vector vTargetOrigin = pEnt->GetAbsOrigin();
		Vector vMyOrigin =  GetAbsOrigin();

		Vector vDir = vTargetOrigin - vMyOrigin;

		if ( vDir.Length() > cl_ragdoll_pronecheck_distance.GetInt() ) 
			continue;

		SetNextClientThink( CLIENT_THINK_ALWAYS );
		m_bFadingOut = true;
		return;
	}

	// if the player is looking at us, delay the fade
	if ( IsRagdollVisible() )
	{
		StartFadeOut( 5.0 );
		return;
	}

	if ( m_fDeathTime > gpGlobals->curtime )
		return;

	//Release(); // Die
	AddEffects( EF_NODRAW );
}

void C_DODRagdoll::StartFadeOut( float fDelay )
{
	m_fDeathTime = gpGlobals->curtime + fDelay;
	SetNextClientThink( CLIENT_THINK_ALWAYS );
}

// ------------------------------------------------------------------------------------------ //
// C_DODPlayer implementation.
// ------------------------------------------------------------------------------------------ //
C_DODPlayer::C_DODPlayer() : 
	m_iv_angEyeAngles( "C_DODPlayer::m_iv_angEyeAngles" )
{
	m_PlayerAnimState = CreatePlayerAnimState( this );
	
	m_Shared.Init( this );

	m_flPitchRecoilAccumulator = 0.0;
	m_flYawRecoilAccumulator = 0.0;
	m_flRecoilTimeRemaining = 0.0;

	m_iProgressBarDuration = 0;
	m_flProgressBarStartTime = 0.0f;

	AddVar( &m_angEyeAngles, &m_iv_angEyeAngles, LATCH_SIMULATION_VAR );

	m_flProneViewOffset = 0.0;
	m_bProneSwayingRight = true;
	m_iIDEntIndex = 0;

	m_Hints.Init( this, NUM_HINTS, g_pszHintMessages );

	m_pFlashlightBeam = NULL;

	m_fNextThinkPushAway = 0.0f;

	// Cold breath.
	m_bColdBreathOn = false;
	m_flColdBreathTimeStart = 0.0f;
	m_flColdBreathTimeEnd = 0.0f;
	m_hColdBreathEmitter = NULL;
	m_hColdBreathMaterial = INVALID_MATERIAL_HANDLE;

	m_flHideHeadIconUntilTime = 0.0f;

	m_iAchievementAwardsMask = 0;
	m_pHeadIconMaterial = NULL;
}


C_DODPlayer::~C_DODPlayer()
{
	m_PlayerAnimState->Release();

	ReleaseFlashlight();

	// Kill the stamina sound!
	if ( m_pStaminaSound )
	{
		CSoundEnvelopeController::GetController().SoundDestroy( m_pStaminaSound );
		m_pStaminaSound = NULL;
	}

	// Cold breath.
	DestroyColdBreathEmitter();
}


C_DODPlayer* C_DODPlayer::GetLocalDODPlayer()
{
	return ToDODPlayer( C_BasePlayer::GetLocalPlayer() );
}

IRagdoll* C_DODPlayer::GetRepresentativeRagdoll() const
{
	if ( m_hRagdoll.Get() )
	{
		C_DODRagdoll *pRagdoll = (C_DODRagdoll*)m_hRagdoll.Get();

		return pRagdoll->GetIRagdoll();
	}
	else
	{
		return NULL;
	}
}

const QAngle& C_DODPlayer::GetRenderAngles()
{
	if ( IsRagdoll() )
	{
		return vec3_angle;
	}
	else
	{
		return m_PlayerAnimState->GetRenderAngles();
	}
}


void C_DODPlayer::UpdateClientSideAnimation()
{
	// Update the animation data. It does the local check here so this works when using
	// a third-person camera (and we don't have valid player angles).
	if ( this == C_DODPlayer::GetLocalDODPlayer() )
		m_PlayerAnimState->Update( EyeAngles()[YAW], m_angEyeAngles[PITCH] );
	else
		m_PlayerAnimState->Update( m_angEyeAngles[YAW], m_angEyeAngles[PITCH] );

	BaseClass::UpdateClientSideAnimation();
}

ConVar dod_playachievementsound( "dod_playachievementsound", "1", FCVAR_ARCHIVE );

void C_DODPlayer::OnAchievementAchieved( int iAchievement )
{
	// don't draw the head icon for a length of time after showing the particle effect
	m_flHideHeadIconUntilTime = gpGlobals->curtime + 2.5;

	if ( dod_playachievementsound.GetBool() )
	{
		EmitSound( "Achievement.Earned" );
	}

	BaseClass::OnAchievementAchieved( iAchievement );
}

int C_DODPlayer::DrawModel( int flags )
{
	int nRetval = BaseClass::DrawModel( flags );
	if ( nRetval != 0 )
	{
		// register to draw the head icon, unless we're hiding it due to the "achieved" particle effect
		if ( gpGlobals->curtime > m_flHideHeadIconUntilTime )
		{
			HeadIconManager()->PlayerDrawn( this );
		}
	}
	return nRetval;
}

void C_DODPlayer::DoAnimationEvent( PlayerAnimEvent_t event, int nData )
{
	m_PlayerAnimState->DoAnimationEvent( event, nData );
}

DODPlayerState C_DODPlayer::State_Get() const
{
	return m_iPlayerState;
}

bool C_DODPlayer::CanShowClassMenu( void )
{
	return ( GetTeamNumber() == TEAM_ALLIES || GetTeamNumber() == TEAM_AXIS );
}

void C_DODPlayer::DoRecoil( int iWpnID, float flWpnRecoil )
{
	float flPitchRecoil = flWpnRecoil;
	float flYawRecoil = flPitchRecoil / 4;

	if( iWpnID == WEAPON_BAR )
		flYawRecoil = MIN( flYawRecoil, 1.3 );

	if ( m_Shared.IsInMGDeploy() )
	{
		flPitchRecoil = 0.0;
		flYawRecoil = 0.0;
	}
	else if ( m_Shared.IsProne() && 
		iWpnID != WEAPON_30CAL && 
		iWpnID != WEAPON_MG42 ) //minor hackage
	{
		flPitchRecoil = flPitchRecoil / 4;
		flYawRecoil = flYawRecoil / 4;
	}
	else if ( m_Shared.IsDucking() )
	{
		flPitchRecoil = flPitchRecoil / 2;
		flYawRecoil = flYawRecoil / 2;
	}

	SetRecoilAmount( flPitchRecoil, flYawRecoil );
}

//Set the amount of pitch and yaw recoil we want to do over the next RECOIL_DURATION seconds
void C_DODPlayer::SetRecoilAmount( float flPitchRecoil, float flYawRecoil )
{
	//Slam the values, abandon previous recoils
	m_flPitchRecoilAccumulator = flPitchRecoil;

	flYawRecoil = flYawRecoil * random->RandomFloat( 0.8, 1.1 );

	if( random->RandomInt( 0,1 ) <= 0 )
		m_flYawRecoilAccumulator = flYawRecoil;
	else
		m_flYawRecoilAccumulator = -flYawRecoil;

	m_flRecoilTimeRemaining = RECOIL_DURATION;
}

//Get the amount of recoil we should do this frame
void C_DODPlayer::GetRecoilToAddThisFrame( float &flPitchRecoil, float &flYawRecoil )
{
	if( m_flRecoilTimeRemaining <= 0 )
	{
		flPitchRecoil = 0.0;
		flYawRecoil = 0.0;
		return;
	}

	float flRemaining = MIN( m_flRecoilTimeRemaining, gpGlobals->frametime );

	float flRecoilProportion = ( flRemaining / RECOIL_DURATION );

	flPitchRecoil = m_flPitchRecoilAccumulator * flRecoilProportion;
	flYawRecoil = m_flYawRecoilAccumulator * flRecoilProportion;

	m_flRecoilTimeRemaining -= gpGlobals->frametime;
}

//-----------------------------------------------------------------------------
// Purpose: Input handling
//-----------------------------------------------------------------------------
bool C_DODPlayer::CreateMove( float flInputSampleTime, CUserCmd *pCmd )
{
	// Lock view if deployed
	if( m_Shared.IsInMGDeploy() )
	{
		m_Shared.ClampDeployedAngles( &pCmd->viewangles );
	}

	//if we're prone and moving, do some sway
	if( m_Shared.IsProne() && IsAlive() )
	{
		float flSpeed = GetAbsVelocity().Length();

		float flSwayAmount = PRONE_SWAY_AMOUNT * gpGlobals->frametime;

		if( flSpeed > 10 )
		{
			if (m_flProneViewOffset >= PRONE_MAX_SWAY)
			{
				m_bProneSwayingRight = false;
			}
			else if (m_flProneViewOffset <= -PRONE_MAX_SWAY)
			{
				m_bProneSwayingRight = true;
			}

			if (m_bProneSwayingRight)
			{
				pCmd->viewangles[YAW]	+= flSwayAmount;
				m_flProneViewOffset		+= flSwayAmount;
			}
			else
			{
				pCmd->viewangles[YAW]	-= flSwayAmount;
				m_flProneViewOffset		-= flSwayAmount;
			}
		}
		else
		{
			// Return to 0 prone sway offset gradually

			//Quick Checks to make sure it isn't bigger or smaller than our sway amount
			if ( (m_flProneViewOffset < 0.0 && m_flProneViewOffset > -flSwayAmount) ||
				 (m_flProneViewOffset > 0.0 && m_flProneViewOffset < flSwayAmount) )
			{
				m_flProneViewOffset = 0.0;
			}

			if (m_flProneViewOffset > 0.0)
			{
				pCmd->viewangles[YAW]	-= flSwayAmount;
				m_flProneViewOffset		-= flSwayAmount;
			}
			else if (m_flProneViewOffset < 0.0)
			{
				pCmd->viewangles[YAW]	+= flSwayAmount;
				m_flProneViewOffset		+= flSwayAmount;
			}
		}
	}

	bool bResult = BaseClass::CreateMove( flInputSampleTime, pCmd );

	AvoidPlayers( pCmd );

	return bResult;
}

// How fast to avoid collisions with center of other object, in units per second
#define AVOID_SPEED 1000.0f
ConVar cl_avoidspeed( "cl_avoidspeed", "1000.0f", FCVAR_CLIENTDLL );
extern ConVar cl_forwardspeed;
extern ConVar cl_backspeed;
extern ConVar cl_sidespeed;

bool C_DODPlayer::ShouldDraw( void )
{
	if( IsDormant() )
		return false;

	// If we're dead, our ragdoll will be drawn for us instead.
	if ( !IsAlive() )
		return false;

	if( GetTeamNumber() == TEAM_SPECTATOR )
		return false;

	if( IsLocalPlayer() )
	{
		if ( IsRagdoll() )
			return true;
	}

	return BaseClass::ShouldDraw();
}

//-----------------------------------------------------------------------------
// Deal with visibility
//-----------------------------------------------------------------------------
void C_DODPlayer::GetToolRecordingState( KeyValues *msg )
{
#ifndef _XBOX
	BaseClass::GetToolRecordingState( msg );
	BaseEntityRecordingState_t *pBaseEntityState = (BaseEntityRecordingState_t*)msg->GetPtr( "baseentity" );
	if ( IsLocalPlayer() )
	{
		pBaseEntityState->m_bVisible = !IsDormant() && IsAlive() && ( GetTeamNumber() != TEAM_SPECTATOR ) &&
			( GetRenderMode() != kRenderNone ) && (GetObserverMode() != OBS_MODE_DEATHCAM) && !IsEffectActive(EF_NODRAW);
	}
#endif
}


CWeaponDODBase* C_DODPlayer::GetActiveDODWeapon() const
{
	C_BaseCombatWeapon *pWpn = GetActiveWeapon();

	if ( !pWpn )
		return NULL;

	return dynamic_cast< CWeaponDODBase* >( pWpn );
}

C_BaseAnimating * C_DODPlayer::BecomeRagdollOnClient()
{
	return NULL;
}

void C_DODPlayer::FireEvent( const Vector& origin, const QAngle& angles, int event, const char *options )
{
	if( event == 7002 )
	{
		if( this == C_BasePlayer::GetLocalPlayer() )
			return;

		CWeaponDODBase *pWeapon = GetActiveDODWeapon();

		if ( !pWeapon )
			return;

		int iAttachment = 2;
		Vector vecOrigin;
		QAngle angAngles;

		if( pWeapon->GetAttachment( iAttachment, vecOrigin, angAngles ) )
		{
			int shellType = atoi(options);

			CEffectData data;
			data.m_nHitBox = shellType;
			data.m_vOrigin = vecOrigin;
			data.m_vAngles = angAngles;
			DispatchEffect( "DOD_EjectBrass", data );
		}
	}
	else
		BaseClass::FireEvent( origin, angles, event, options );

	/*
	// MATTTODO: water footstep effects
	if( event == 7001 )
	{
		bool bInWater = ( enginetrace->GetPointContents(origin) & CONTENTS_WATER );

		if( bInWater )
		{
			//run splash
			CEffectData data;

			//trace up from foot position to the water surface
			trace_t tr;
			Vector vecTrace(0,0,1024);
			UTIL_TraceLine( origin, origin + vecTrace, MASK_WATER, NULL, COLLISION_GROUP_NONE, &tr );
			if ( tr.fractionleftsolid )
			{
				data.m_vOrigin = origin + (vecTrace * tr.fractionleftsolid);
			}
			else
			{
				data.m_vOrigin = origin;
			}
			
			data.m_vNormal = Vector( 0,0,1 );
			data.m_flScale = random->RandomFloat( 4.0f, 5.0f );
			DispatchEffect( "watersplash", data );
		}		
	}
	else if( event == 7002 )
	{
		bool bInWater = ( enginetrace->GetPointContents(origin) & CONTENTS_WATER );
		
		if( bInWater )
		{
			//walk ripple
			CEffectData data;

			//trace up from foot position to the water surface
			trace_t tr;
			Vector vecTrace(0,0,1024);
			UTIL_TraceLine( origin, origin + vecTrace, MASK_WATER, NULL, COLLISION_GROUP_NONE, &tr );
			if ( tr.fractionleftsolid )
			{
				data.m_vOrigin = origin + (vecTrace * tr.fractionleftsolid);
			}
			else
			{
				data.m_vOrigin = origin;
			}
	
			data.m_vNormal = Vector( 0,0,1 );
			data.m_flScale = random->RandomFloat( 4.0f, 7.0f );
			DispatchEffect( "waterripple", data );
		}
	}
	*/
}
// NVNT gate for spectating.
static bool inSpectating_Haptics = false;
// NVNT check grenade things ( -- this is here to avoid modificaions to the grenade class -- )
static bool s_holdingGrenade = false;
static bool s_grenadePinPulled = false;
static bool s_grenadeArmed = false;
static bool s_bombPlanting = false;
void C_DODPlayer::ClientThink()
{
	BaseClass::ClientThink();

	if ( gpGlobals->curtime >= m_fNextThinkPushAway )
	{
		PerformObstaclePushaway( this );
		m_fNextThinkPushAway =  gpGlobals->curtime + PUSHAWAY_THINK_INTERVAL;
	}

	if ( IsLocalPlayer() )
	{	
		UpdateIDTarget();

		StaminaSoundThink();

		// Recoil
		QAngle viewangles;
		engine->GetViewAngles( viewangles );

		float flYawRecoil;
		float flPitchRecoil;
		GetRecoilToAddThisFrame( flPitchRecoil, flYawRecoil );

		// Recoil
		if( flPitchRecoil > 0 )
		{
			//add the recoil pitch
			viewangles[PITCH] -= flPitchRecoil;
			viewangles[YAW] += flYawRecoil;
		}

		// Sniper sway
		if( m_Shared.IsSniperZoomed() && GetFOV() <= 20 )
		{
			//multiply by frametime to balance for framerate changes
			float x = gpGlobals->frametime * cos( gpGlobals->curtime );
			float y = gpGlobals->frametime * 2 * cos( 2 * gpGlobals->curtime );

			float scale;

			if( m_Shared.IsDucking() )				//duck
				scale = ZOOM_SWAY_DUCKING;
			else if( m_Shared.IsProne() )
				scale = ZOOM_SWAY_PRONE;
			else									//standing
				scale = ZOOM_SWAY_STANDING; 

			if( GetAbsVelocity().Length() > 10 )
				scale += ZOOM_SWAY_MOVING_PENALTY;

			viewangles[PITCH] += y * scale;
			viewangles[YAW] += x * scale;
		}

		engine->SetViewAngles( viewangles );
		// NVNT check spectator nav.
		if(	( ( GetTeamNumber() == TEAM_SPECTATOR ) || ( !this->IsAlive() ) ) ) {
				if(!inSpectating_Haptics)
				{
					if ( haptics )
						haptics->SetNavigationClass("spectate");
					inSpectating_Haptics = true;
				}
		}else{
			if(inSpectating_Haptics) {
				if ( haptics )
					haptics->SetNavigationClass("on_foot");
				inSpectating_Haptics = false;
			}
		}

		// NVNT check grenade things ( -- this is here to avoid modificaions to the grenade class -- )
		C_WeaponDODBaseGrenade *heldGrenade = dynamic_cast<C_WeaponDODBaseGrenade*>(GetActiveDODWeapon());
		if(heldGrenade)
		{
			if(!s_holdingGrenade)
			{
				s_holdingGrenade = true;
			}
			bool pinPulled = heldGrenade->m_bPinPulled;
			if(pinPulled != s_grenadePinPulled) {
				if(pinPulled)
				{
					if ( haptics )
						haptics->ProcessHapticEvent(3, "Weapons", heldGrenade->GetClassname(), "PinPulled");
				}else {
					if ( haptics )
						haptics->ProcessHapticEvent(3, "Weapons", heldGrenade->GetClassname(), "PinReplaced");
				}
				s_grenadePinPulled = pinPulled;
			}
			bool grenadeArmed = heldGrenade->m_bArmed;
			if(grenadeArmed != s_grenadeArmed) {
				if(grenadeArmed)
				{
					if ( haptics )
						haptics->ProcessHapticEvent(3, "Weapons", heldGrenade->GetClassname(), "Armed");
				}else {
					if ( haptics )
						haptics->ProcessHapticEvent(3, "Weapons", heldGrenade->GetClassname(), "Unarmed");
				}
				s_grenadeArmed = grenadeArmed;
			}
		}else{
			if( s_holdingGrenade ) 
			{
				if(s_grenadeArmed && s_grenadePinPulled) {
					if ( haptics )
						haptics->ProcessHapticEvent(3, "Weapons", "Grenades", "Thrown");
				}
				s_holdingGrenade = false;
				s_grenadeArmed = false;
				s_grenadePinPulled = false;
			}
			C_DODBaseBombWeapon *heldBomb = dynamic_cast<C_DODBaseBombWeapon*>(GetActiveDODWeapon());

			if(heldBomb) {
				bool isPlanting = heldBomb->IsPlanting();
				if(isPlanting!=s_bombPlanting) {
					if(isPlanting) {
						if(!s_bombPlanting) {
							s_bombPlanting = true;
							if ( haptics )
								haptics->ProcessHapticEvent(3, "Weapons", heldBomb->GetClassname(), "Plant");
						}
					}else{
						if(s_bombPlanting) {
							if ( haptics )
								haptics->ProcessHapticEvent(3, "Weapons", heldBomb->GetClassname(), "StopPlant");
						}
					}
				}
			}else if(s_bombPlanting) {
				s_bombPlanting = false;
				if ( haptics )
					haptics->ProcessHapticEvent(3, "Weapons", "Bomb", "Complete");
			}
		}
		
	}
	else
	{
		// Cold breath.
		UpdateColdBreath();
	}
}

// Start or stop the stamina breathing sound if necessary
void C_DODPlayer::StaminaSoundThink( void )
{
	if ( m_bPlayingLowStaminaSound )
	{
		if ( !IsAlive() || m_Shared.GetStamina() >= LOW_STAMINA_THRESHOLD )
		{
			// stop the sprint sound
			CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
			controller.SoundFadeOut( m_pStaminaSound, 1.0, true );

			// SoundFadeOut will destroy this sound, so we will have to create another one
			// if we go below the threshold again soon
			m_pStaminaSound = NULL;

			m_bPlayingLowStaminaSound = false;
		}
	}
	else
	{
		if ( IsAlive() && m_Shared.GetStamina() < LOW_STAMINA_THRESHOLD )
		{
			// we are alive and have low stamina
			CLocalPlayerFilter filter;

			CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();

			if ( !m_pStaminaSound )
                m_pStaminaSound = controller.SoundCreate( filter, entindex(), "Player.Sprint" );

			controller.Play( m_pStaminaSound, 0.0, 100 );
			controller.SoundChangeVolume( m_pStaminaSound, 1.0, 2.0 );

			m_bPlayingLowStaminaSound = true;
		}
	}
}

void C_DODPlayer::OnDataChanged( DataUpdateType_t type )
{
	BaseClass::OnDataChanged( type );

	if ( type == DATA_UPDATE_CREATED )
	{
		SetNextClientThink( CLIENT_THINK_ALWAYS );
	}

	UpdateVisibility();
}

void C_DODPlayer::PostDataUpdate( DataUpdateType_t updateType )
{
	// C_BaseEntity assumes we're networking the entity's angles, so pretend that it
	// networked the same value we already have.
	SetNetworkAngles( GetLocalAngles() );

	BaseClass::PostDataUpdate( updateType );

	if( m_bSpawnInterpCounter != m_bSpawnInterpCounterCache )
	{
		if ( IsLocalPlayer() )
		{
			LocalPlayerRespawn();
		}

		m_bSpawnInterpCounterCache = m_bSpawnInterpCounter.m_Value;
	}
}

// Called every time the player respawns
void C_DODPlayer::LocalPlayerRespawn( void )
{
	MoveToLastReceivedPosition( true );
	ResetLatched();

	ResetToneMapping(1.0);

	m_Shared.m_bForceProneChange = true;

	m_flLastRespawnTime = gpGlobals->curtime;
}

class C_FadingPhysPropClientside : public C_PhysPropClientside
{
public:	
	DECLARE_CLASS( C_FadingPhysPropClientside, C_PhysPropClientside );

	// if we wake, extend fade time

	virtual void ImpactTrace( trace_t *pTrace, int iDamageType, const char *pCustomImpactName )
	{
		// If we haven't started fading
		if( GetRenderColor().a >= 255 )
		{
			// delay the fade
			StartFadeOut( 10.0 );

			// register the impact
			BaseClass::ImpactTrace( pTrace, iDamageType, pCustomImpactName );
		}		
	}
};

void C_DODPlayer::PopHelmet( Vector vecDir, Vector vecForceOrigin, int iModel )
{
	if ( IsDormant() )
		return;	// We can't see them anyway, just bail

	C_FadingPhysPropClientside *pEntity = new C_FadingPhysPropClientside();

	if ( !pEntity )
		return;

	const model_t *model = modelinfo->GetModel( iModel );

	if ( !model )
	{
		DevMsg("CTempEnts::PhysicsProp: model index %i not found\n", iModel );
		return;
	}

	Vector vecHead;
	QAngle angHeadAngles;

	{
		C_BaseAnimating::AutoAllowBoneAccess boneaccess( true, false );
		int iAttachment = LookupAttachment( "head" );
		GetAttachment( iAttachment, vecHead, angHeadAngles );	//attachment 1 is the head attachment
	}

	pEntity->SetModelName( modelinfo->GetModelName(model) );
	pEntity->SetAbsOrigin( vecHead );
	pEntity->SetAbsAngles( angHeadAngles );
	pEntity->SetPhysicsMode( PHYSICS_MULTIPLAYER_CLIENTSIDE );

	if ( !pEntity->Initialize() )
	{
		pEntity->Release();
		return;
	}

	IPhysicsObject *pPhysicsObject = pEntity->VPhysicsGetObject();

	if( pPhysicsObject )
	{
#ifdef DEBUG
		if( vecForceOrigin == vec3_origin )
		{
			vecForceOrigin = GetAbsOrigin();
		}
#endif

		Vector vecForce = vecDir;		
		Vector vecOffset = vecForceOrigin - pEntity->GetAbsOrigin();
		pPhysicsObject->ApplyForceOffset( vecForce, vecOffset );
	}
	else
	{
		// failed to create a physics object
		pEntity->Release();
		return;
	}

	pEntity->StartFadeOut( 10.0 );
}

void C_DODPlayer::ReceiveMessage( int classID, bf_read &msg )
{
	if ( classID != GetClientClass()->m_ClassID )
	{
		// message is for subclass
		BaseClass::ReceiveMessage( classID, msg );
		return;
	}

	int messageType = msg.ReadByte();
	switch( messageType )
	{
	case DOD_PLAYER_POP_HELMET:
		{
			Vector	vecDir, vecForceOffset;
			msg.ReadBitVec3Coord( vecDir );
			msg.ReadBitVec3Coord( vecForceOffset );

			int model = msg.ReadShort();

			PopHelmet( vecDir, vecForceOffset, model );
		}
		break;
	case DOD_PLAYER_REMOVE_DECALS:
		{
			RemoveAllDecals();
		}
		break;
	default:
		break;
	}
}

//-----------------------------------------------------------------------------
// Purpose: Update this client's target entity
//-----------------------------------------------------------------------------
void C_DODPlayer::UpdateIDTarget()
{
	Assert( IsLocalPlayer() );

	// Clear old target and find a new one
 	m_iIDEntIndex = 0;

	// don't show IDs in chase spec mode
	if ( GetObserverMode() == OBS_MODE_CHASE || 
		 GetObserverMode() == OBS_MODE_DEATHCAM )
		 return;

	trace_t tr;
	Vector vecStart, vecEnd;
	VectorMA( MainViewOrigin(), 1500, MainViewForward(), vecEnd );
	VectorMA( MainViewOrigin(), 10,   MainViewForward(), vecStart );
	UTIL_TraceLine( vecStart, vecEnd, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );

	C_BaseEntity *pEntity = NULL;
	if ( !tr.startsolid && tr.DidHitNonWorldEntity() )
	{
		pEntity = tr.m_pEnt;

		if ( pEntity && (pEntity != this) )
		{
			m_iIDEntIndex = pEntity->entindex();
		}
	}

	// if we haven't done the weapon hint, and this entity is a weapon,
	// show the weapon hint
	if ( m_Hints.HasPlayedHint( HINT_PICK_UP_WEAPON ) == false && pEntity )
	{
		Vector vecDist = vecStart - tr.endpos;

		// if m_iIDEntIndex is a CWeaponDODBase, show pick up hint
		CWeaponDODBase *pWpn = dynamic_cast<CWeaponDODBase *>( pEntity );
		if ( pWpn && vecDist.Length() < 100 )
		{
			HintMessage( HINT_PICK_UP_WEAPON );
		}
	}
}

bool C_DODPlayer::ShouldAutoReload( void )
{
	return cl_autoreload.GetBool();
}

bool C_DODPlayer::ShouldAutoRezoom( void )
{
	return cl_autorezoom.GetBool();
}

void C_DODPlayer::CheckGrenadeHint( Vector vecGrenadeOrigin )
{
	if ( m_Hints.HasPlayedHint( HINT_PICK_UP_GRENADE ) == false )
	{
		// if its within 500 units
		float flDist = ( vecGrenadeOrigin - GetAbsOrigin() ).Length2D();

		if ( flDist < 500 )
		{
			m_Hints.HintMessage( HINT_PICK_UP_GRENADE );
		}
	}
}

void C_DODPlayer::CheckBombTargetPlantHint( void )
{
	if ( m_Hints.HasPlayedHint( HINT_BOMB_TARGET ) == false )
	{
		m_Hints.HintMessage( HINT_BOMB_TARGET );
	}
}

void C_DODPlayer::CheckBombTargetDefuseHint( void )
{
	if ( m_Hints.HasPlayedHint( HINT_DEFUSE_BOMB ) == false )
	{
		m_Hints.HintMessage( HINT_DEFUSE_BOMB );
	}
}

void C_DODPlayer::LowerWeapon( void )
{
	m_bWeaponLowered = true;
}

void C_DODPlayer::RaiseWeapon( void )
{
	m_bWeaponLowered = false;
}

bool C_DODPlayer::IsWeaponLowered( void )
{
	if ( GetMoveType() == MOVETYPE_LADDER )
		return true;

	CWeaponDODBase *pWeapon = GetActiveDODWeapon();

	if ( !pWeapon )
		return false;

	// Lower when underwater ( except if its melee )
	if ( GetWaterLevel() > 2 && pWeapon->GetDODWpnData().m_WeaponType != WPN_TYPE_MELEE )
		return true;

	if ( m_Shared.IsProne() && GetAbsVelocity().LengthSqr() > 1 )
		return true;

	if ( m_Shared.IsGoingProne() || m_Shared.IsGettingUpFromProne() )
		return true;

	if ( m_Shared.IsJumping() )
		return true;

	if ( m_Shared.IsDefusing() )
		return true;

	// Lower losing team's weapons in bonus round
	int state = DODGameRules()->State_Get();

	if ( state == STATE_ALLIES_WIN && GetTeamNumber() == TEAM_AXIS )
		return true;

	if ( state == STATE_AXIS_WIN && GetTeamNumber() == TEAM_ALLIES )
		return true;

	if ( m_Shared.IsBazookaDeployed() )
		return false;

	Vector vel = GetAbsVelocity();
	if ( vel.Length2D() < 50 )
		return false;

	if ( m_nButtons & IN_SPEED && ( m_nButtons & IN_FORWARD ) &&
		m_Shared.GetStamina() >= 5 &&
		!m_Shared.IsDucking() )
		return true;

	return m_bWeaponLowered;
}

// Shadows

ConVar cl_blobbyshadows( "cl_blobbyshadows", "0", FCVAR_CLIENTDLL );
ShadowType_t C_DODPlayer::ShadowCastType( void ) 
{
	if ( !IsVisible() )
		return SHADOWS_NONE;

	C_DODPlayer *pLocalPlayer = C_DODPlayer::GetLocalDODPlayer();

	// if we're first person spectating this player
	if ( pLocalPlayer && 
		pLocalPlayer->GetObserverTarget() == this &&
		pLocalPlayer->GetObserverMode() == OBS_MODE_IN_EYE )
	{
		return SHADOWS_NONE;		
	}

	if( cl_blobbyshadows.GetBool() )
		return SHADOWS_SIMPLE;

	return SHADOWS_RENDER_TO_TEXTURE_DYNAMIC;
}

float g_flFattenAmt = 4;
void C_DODPlayer::GetShadowRenderBounds( Vector &mins, Vector &maxs, ShadowType_t shadowType )
{
	if ( shadowType == SHADOWS_SIMPLE )
	{
		// Don't let the render bounds change when we're using blobby shadows, or else the shadow
		// will pop and stretch.
		mins = CollisionProp()->OBBMins();
		maxs = CollisionProp()->OBBMaxs();
	}
	else
	{
		GetRenderBounds( mins, maxs );

		// We do this because the normal bbox calculations don't take pose params into account, and 
		// the rotation of the guy's upper torso can place his gun a ways out of his bbox, and 
		// the shadow will get cut off as he rotates.
		//
		// Thus, we give it some padding here.
		mins -= Vector( g_flFattenAmt, g_flFattenAmt, 0 );
		maxs += Vector( g_flFattenAmt, g_flFattenAmt, 0 );
	}
}


void C_DODPlayer::GetRenderBounds( Vector& theMins, Vector& theMaxs )
{
	// TODO POSTSHIP - this hack/fix goes hand-in-hand with a fix in CalcSequenceBoundingBoxes in utils/studiomdl/simplify.cpp.
	// When we enable the fix in CalcSequenceBoundingBoxes, we can get rid of this.
	//
	// What we're doing right here is making sure it only uses the bbox for our lower-body sequences since,
	// with the current animations and the bug in CalcSequenceBoundingBoxes, are WAY bigger than they need to be.
	C_BaseAnimating::GetRenderBounds( theMins, theMaxs );
}


bool C_DODPlayer::GetShadowCastDirection( Vector *pDirection, ShadowType_t shadowType ) const
{ 
	if ( shadowType == SHADOWS_SIMPLE )
	{
		// Blobby shadows should sit directly underneath us.
		pDirection->Init( 0, 0, -1 );
		return true;
	}
	else
	{
		return BaseClass::GetShadowCastDirection( pDirection, shadowType );
	}
}

ConVar cl_muzzleflash_dlight_3rd( "cl_muzzleflash_dlight_3rd", "1" );

void C_DODPlayer::ProcessMuzzleFlashEvent()
{
	CBasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();

	bool bInToolRecordingMode = ToolsEnabled() && clienttools->IsInRecordingMode();

	// Reenable when the weapons have muzzle flash attachments in the right spot.
	if ( this == pLocalPlayer && !bInToolRecordingMode )
		return; // don't show own world muzzle flashs in for localplayer

	if ( pLocalPlayer && pLocalPlayer->GetObserverMode() == OBS_MODE_IN_EYE )
	{
		// also don't show in 1st person spec mode
		if ( pLocalPlayer->GetObserverTarget() == this )
			return;
	}

	CWeaponDODBase *pWeapon = GetActiveDODWeapon();
	if ( !pWeapon )
		return;

	int nModelIndex = pWeapon->GetModelIndex();
	int nWorldModelIndex = pWeapon->GetWorldModelIndex();
	if ( bInToolRecordingMode && nModelIndex != nWorldModelIndex )
	{
		pWeapon->SetModelIndex( nWorldModelIndex );
	}

	Vector vecOrigin;
	QAngle angAngles;

	//MATTTODO - use string names of the weapon
	const static int iMuzzleFlashAttachment = 1;
	const static int iEjectBrassAttachment = 2;

	// If we have an attachment, then stick a light on it.
	if ( cl_muzzleflash_dlight_3rd.GetBool() && pWeapon->GetAttachment( iMuzzleFlashAttachment, vecOrigin, angAngles ) )
	{
		// Muzzleflash light
		dlight_t *el = effects->CL_AllocDlight( LIGHT_INDEX_MUZZLEFLASH );
		el->origin = vecOrigin;
		el->radius = 70; 

		if ( pWeapon->GetDODWpnData().m_WeaponType == WPN_TYPE_SNIPER )
			el->radius = 150;

		el->decay = el->radius / 0.05f;
		el->die = gpGlobals->curtime + 0.05f;
		el->color.r = 255;
		el->color.g = 192;
		el->color.b = 64;
		el->color.exponent = 5;

		if ( bInToolRecordingMode )
		{
			Color clr( el->color.r, el->color.g, el->color.b );

			KeyValues *msg = new KeyValues( "TempEntity" );

			msg->SetInt( "te", TE_DYNAMIC_LIGHT );
			msg->SetString( "name", "TE_DynamicLight" );
			msg->SetFloat( "time", gpGlobals->curtime );
			msg->SetFloat( "duration", el->die );
			msg->SetFloat( "originx", el->origin.x );
			msg->SetFloat( "originy", el->origin.y );
			msg->SetFloat( "originz", el->origin.z );
			msg->SetFloat( "radius", el->radius );
			msg->SetFloat( "decay", el->decay );
			msg->SetColor( "color", clr );
			msg->SetInt( "exponent", el->color.exponent );
			msg->SetInt( "lightindex", LIGHT_INDEX_MUZZLEFLASH );

			ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );
			msg->deleteThis();
		}
	}

	const char *pszMuzzleFlashEffect = NULL;

	switch( pWeapon->GetDODWpnData().m_iMuzzleFlashType )
	{
	case DOD_MUZZLEFLASH_PISTOL:
		pszMuzzleFlashEffect = "muzzle_pistols";
		break;
	case DOD_MUZZLEFLASH_AUTO:
		pszMuzzleFlashEffect = "muzzle_fullyautomatic";
		break;
	case DOD_MUZZLEFLASH_RIFLE:
		pszMuzzleFlashEffect = "muzzle_rifles";
		break;
	case DOD_MUZZLEFLASH_ROCKET:
		pszMuzzleFlashEffect = "muzzle_rockets";
		break;
	case DOD_MUZZLEFLASH_MG42:
		pszMuzzleFlashEffect = "muzzle_mg42";
		break;
	default:
		break;
	}

	if ( pszMuzzleFlashEffect )
	{
		DispatchParticleEffect( pszMuzzleFlashEffect, PATTACH_POINT_FOLLOW, pWeapon, 1 );
	}

	if( pWeapon->ShouldAutoEjectBrass() )
	{
		// shell eject
		if( pWeapon->GetAttachment( iEjectBrassAttachment, vecOrigin, angAngles ) )
		{
			int shellType = pWeapon->GetEjectBrassShellType();

			CEffectData data;
			data.m_nHitBox = shellType;
			data.m_vOrigin = vecOrigin;
			data.m_vAngles = angAngles;
			DispatchEffect( "DOD_EjectBrass", data );
		}
	}

	if ( bInToolRecordingMode && nModelIndex != nWorldModelIndex )
	{
		pWeapon->SetModelIndex( nModelIndex );
	}
}

void C_DODPlayer::NotifyShouldTransmit( ShouldTransmitState_t state )
{
	// Remove all effects if we go out of the PVS.
	if ( state == SHOULDTRANSMIT_END )
	{
		if( m_pFlashlightBeam != NULL )
		{
			ReleaseFlashlight();
		}
	}

	BaseClass::NotifyShouldTransmit( state );
}

void C_DODPlayer::Simulate( void )
{
	if( this != C_BasePlayer::GetLocalPlayer() )
	{
		if ( IsEffectActive( EF_DIMLIGHT ) )
		{
			QAngle eyeAngles = m_angEyeAngles;
			Vector vForward;
			AngleVectors( eyeAngles, &vForward );

			int iAttachment = LookupAttachment( "anim_attachment_RH" );

			Vector vecOrigin;
			QAngle dummy;
			GetAttachment( iAttachment, vecOrigin, dummy );

			trace_t tr;
			UTIL_TraceLine( vecOrigin, vecOrigin + (vForward * 200), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );

			if( !m_pFlashlightBeam )
			{
				BeamInfo_t beamInfo;
				beamInfo.m_nType = TE_BEAMPOINTS;
				beamInfo.m_vecStart = tr.startpos;
				beamInfo.m_vecEnd = tr.endpos;
				beamInfo.m_pszModelName = "sprites/glow01.vmt";
				beamInfo.m_pszHaloName = "sprites/glow01.vmt";
				beamInfo.m_flHaloScale = 3.0;
				beamInfo.m_flWidth = 8.0f;
				beamInfo.m_flEndWidth = 35.0f;
				beamInfo.m_flFadeLength = 300.0f;
				beamInfo.m_flAmplitude = 0;
				beamInfo.m_flBrightness = 60.0;
				beamInfo.m_flSpeed = 0.0f;
				beamInfo.m_nStartFrame = 0.0;
				beamInfo.m_flFrameRate = 0.0;
				beamInfo.m_flRed = 255.0;
				beamInfo.m_flGreen = 255.0;
				beamInfo.m_flBlue = 255.0;
				beamInfo.m_nSegments = 8;
				beamInfo.m_bRenderable = true;
				beamInfo.m_flLife = 0.5;
				beamInfo.m_nFlags = FBEAM_FOREVER | FBEAM_ONLYNOISEONCE | FBEAM_NOTILE | FBEAM_HALOBEAM;

				m_pFlashlightBeam = beams->CreateBeamPoints( beamInfo );
			}

			if( m_pFlashlightBeam )
			{
				BeamInfo_t beamInfo;
				beamInfo.m_vecStart = tr.startpos;
				beamInfo.m_vecEnd = tr.endpos;
				beamInfo.m_flRed = 255.0;
				beamInfo.m_flGreen = 255.0;
				beamInfo.m_flBlue = 255.0;

				beams->UpdateBeamInfo( m_pFlashlightBeam, beamInfo );

				dlight_t *el = effects->CL_AllocDlight( 0 );
				el->origin = tr.endpos;
				el->radius = 50; 
				el->color.r = 200;
				el->color.g = 200;
				el->color.b = 200;
				el->die = gpGlobals->curtime + 0.1;
			}
		}
		else if ( m_pFlashlightBeam )
		{
			ReleaseFlashlight();
		}
	}

	BaseClass::Simulate();
}

void C_DODPlayer::ReleaseFlashlight( void )
{
	if( m_pFlashlightBeam )
	{
		m_pFlashlightBeam->flags = 0;
		m_pFlashlightBeam->die = gpGlobals->curtime - 1;

		m_pFlashlightBeam = NULL;
	}
}

bool C_DODPlayer::SetFOV( CBaseEntity *pRequester, int FOV, float zoomRate /* = 0.0f */ )
{
	/*
	if( FOV < 30 )
	{
		// fade in
		ScreenFade_t sf;
		memset( &sf, 0, sizeof( sf ) );
		sf.a = 255;
		sf.r = 0;
		sf.g = 0;
		sf.b = 0;
		sf.duration = (unsigned short)((float)(1<<SCREENFADE_FRACBITS) * 2.5f );
		sf.fadeFlags = FFADE_IN;
		vieweffects->Fade( sf );
	}
	else
	{
		//cancel the fade if its active
		ScreenFade_t sf;
		memset( &sf, 0, sizeof( sf ) );
		sf.fadeFlags = FFADE_IN | FFADE_PURGE;
		vieweffects->Fade( sf );
	}
	*/

	return true;
}

void C_DODPlayer::CalcObserverView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov )
{
	if( GetObserverMode() == OBS_MODE_DEATHCAM )
	{
		CalcDODDeathCamView( eyeOrigin, eyeAngles, fov );
	}
	else
		BaseClass::CalcObserverView( eyeOrigin, eyeAngles, fov );
}

static Vector WALL_MIN(-WALL_OFFSET,-WALL_OFFSET,-WALL_OFFSET);
static Vector WALL_MAX(WALL_OFFSET,WALL_OFFSET,WALL_OFFSET);

void C_DODPlayer::CalcDODDeathCamView(Vector& eyeOrigin, QAngle& eyeAngles, float& fov)
{
	CBaseEntity	* killer = GetObserverTarget();

	//float interpolation = ( gpGlobals->curtime - m_flDeathTime ) / DEATH_ANIMATION_TIME;

	// Interpolate very quickly to the killer and follow
	float interpolation = ( gpGlobals->curtime - m_flDeathTime ) / 0.2f;
	interpolation = clamp( interpolation, 0.0f, 1.0f );

	m_flObserverChaseDistance += gpGlobals->frametime*48.0f;
	m_flObserverChaseDistance = clamp( m_flObserverChaseDistance, CHASE_CAM_DISTANCE_MIN, CHASE_CAM_DISTANCE_MAX );

	QAngle aForward = eyeAngles = EyeAngles();
	Vector origin = EyePosition();			

	IRagdoll *pRagdoll = GetRepresentativeRagdoll();
	if ( pRagdoll )
	{
		origin = pRagdoll->GetRagdollOrigin();
		origin.z += VEC_DEAD_VIEWHEIGHT_SCALED( this ).z; // look over ragdoll, not through
	}

	if ( killer && (killer != this) ) 
	{
		Vector vecKiller = killer->GetAbsOrigin();
		
		C_DODPlayer *player = ToDODPlayer( killer );
		if ( player && player->IsAlive() )
		{
			if ( player->m_Shared.IsProne() )
			{
				VectorAdd( vecKiller, VEC_PRONE_VIEW_SCALED( this ), vecKiller );
			}
			else if( player->GetFlags() & FL_DUCKING )
			{
				VectorAdd( vecKiller, VEC_DUCK_VIEW_SCALED( this ), vecKiller );
			}
			else
			{
				VectorAdd( vecKiller, VEC_VIEW_SCALED( this ), vecKiller );
			}
		}

		Vector vecToKiller = vecKiller - origin;
		QAngle aKiller;
		VectorAngles( vecToKiller, aKiller );
		InterpolateAngles( aForward, aKiller, eyeAngles, interpolation );
	}

	Vector vForward; AngleVectors( eyeAngles, &vForward );

	VectorNormalize( vForward );

	VectorMA( origin, -m_flObserverChaseDistance, vForward, eyeOrigin );

	trace_t trace; // clip against world
	C_BaseEntity::PushEnableAbsRecomputations( false ); // HACK don't recompute positions while doing RayTrace
	UTIL_TraceHull( origin, eyeOrigin, WALL_MIN, WALL_MAX, MASK_SOLID, this, COLLISION_GROUP_NONE, &trace );
	C_BaseEntity::PopEnableAbsRecomputations();

	if (trace.fraction < 1.0)
	{
		eyeOrigin = trace.endpos;
		m_flObserverChaseDistance = VectorLength(origin - eyeOrigin);
	}

	fov = GetFOV();
}

void C_DODPlayer::CalcChaseCamView(Vector& eyeOrigin, QAngle& eyeAngles, float& fov)
{
	C_BaseEntity *target = GetObserverTarget();

	if ( !target ) 
	{
		// just copy a save in-map position
		VectorCopy( EyePosition(), eyeOrigin );
		VectorCopy( EyeAngles(), eyeAngles );
		return;
	};

	Vector forward, viewpoint;

	// GetRenderOrigin() returns ragdoll pos if player is ragdolled
	Vector origin = target->GetRenderOrigin();

	C_DODPlayer *player = ToDODPlayer( target );

	if ( player && player->IsAlive() )
	{
		if ( player->m_Shared.IsProne() )
		{
			VectorAdd( origin, VEC_PRONE_VIEW_SCALED( this ), origin );
		}
		else if( player->GetFlags() & FL_DUCKING )
		{
			VectorAdd( origin, VEC_DUCK_VIEW_SCALED( this ), origin );
		}
		else
		{
			VectorAdd( origin, VEC_VIEW_SCALED( this ), origin );
		}
	}
	else
	{
		// assume it's the players ragdoll
		VectorAdd( origin, VEC_DEAD_VIEWHEIGHT_SCALED( this ), origin );
	}

	QAngle viewangles;

	if ( IsLocalPlayer() )
	{
		engine->GetViewAngles( viewangles );
	}
	else
	{
		viewangles = EyeAngles();
	}

	m_flObserverChaseDistance += gpGlobals->frametime*48.0f;
	m_flObserverChaseDistance = clamp( m_flObserverChaseDistance, CHASE_CAM_DISTANCE_MIN, CHASE_CAM_DISTANCE_MAX );

	AngleVectors( viewangles, &forward );

	VectorNormalize( forward );

	VectorMA(origin, -m_flObserverChaseDistance, forward, viewpoint );

	trace_t trace;
	C_BaseEntity::PushEnableAbsRecomputations( false ); // HACK don't recompute positions while doing RayTrace
	UTIL_TraceHull( origin, viewpoint, WALL_MIN, WALL_MAX, MASK_SOLID, target, COLLISION_GROUP_NONE, &trace );
	C_BaseEntity::PopEnableAbsRecomputations();

	if (trace.fraction < 1.0)
	{
		viewpoint = trace.endpos;
		m_flObserverChaseDistance = VectorLength(origin - eyeOrigin);
	}

	VectorCopy( viewangles, eyeAngles );
	VectorCopy( viewpoint, eyeOrigin );

	fov = GetFOV();
}

extern ConVar spec_freeze_traveltime;
extern ConVar spec_freeze_time;
extern ConVar cl_dod_freezecam;

//-----------------------------------------------------------------------------
// Purpose: Calculate the view for the player while he's in freeze frame observer mode
//-----------------------------------------------------------------------------
void C_DODPlayer::CalcFreezeCamView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov )
{
	C_BaseEntity *pTarget = GetObserverTarget();
	if ( !pTarget || !cl_dod_freezecam.GetBool() )
	{
		CalcDeathCamView( eyeOrigin, eyeAngles, fov );
		return;
	}

	// Zoom towards our target
	float flCurTime = (gpGlobals->curtime - m_flFreezeFrameStartTime);
	float flBlendPerc = clamp( flCurTime / spec_freeze_traveltime.GetFloat(), 0, 1 );
	flBlendPerc = SimpleSpline( flBlendPerc );

	// Find the position we would like to be lookin at
	Vector vecCamDesired = pTarget->GetObserverCamOrigin();	// Returns ragdoll origin if they're ragdolled
	VectorAdd( vecCamDesired, GetChaseCamViewOffset( pTarget ), vecCamDesired );
	Vector vecCamTarget = vecCamDesired;
	if ( !pTarget->IsAlive() )
	{
		vecCamTarget.z += pTarget->GetBaseAnimating() ? VEC_DEAD_VIEWHEIGHT_SCALED( pTarget->GetBaseAnimating() ).z : VEC_DEAD_VIEWHEIGHT.z;	// look over ragdoll, not through
	}

	// Figure out a view position in front of the target
	Vector vecEyeOnPlane = eyeOrigin;
	vecEyeOnPlane.z = vecCamTarget.z;
	Vector vecTargetPos = vecCamTarget;
	Vector vecToTarget = vecTargetPos - vecEyeOnPlane;
	VectorNormalize( vecToTarget );

	// Stop a few units away from the target, and shift up to be at the same height
	vecTargetPos = vecCamTarget - (vecToTarget * m_flFreezeFrameDistance);
	float flEyePosZ = pTarget->EyePosition().z;
	vecTargetPos.z = flEyePosZ + m_flFreezeZOffset;

	// Now trace out from the target, so that we're put in front of any walls
	trace_t trace;
	C_BaseEntity::PushEnableAbsRecomputations( false ); // HACK don't recompute positions while doing RayTrace
	UTIL_TraceLine( vecCamTarget, vecTargetPos, MASK_SOLID, pTarget, COLLISION_GROUP_NONE, &trace );
	C_BaseEntity::PopEnableAbsRecomputations();
	if (trace.fraction < 1.0 )
	{
		// The camera's going to be really close to the target. So we don't end up
		// looking at someone's chest, aim close freezecams at the target's eyes.
		vecTargetPos = trace.endpos;
		vecCamTarget = vecCamDesired;

		// To stop all close in views looking up at character's chins, move the view up.
		vecTargetPos.z += fabs(vecCamTarget.z - vecTargetPos.z) * 0.85;
		C_BaseEntity::PushEnableAbsRecomputations( false ); // HACK don't recompute positions while doing RayTrace
		UTIL_TraceLine( vecCamTarget, vecTargetPos, MASK_SOLID, pTarget, COLLISION_GROUP_NONE, &trace );
		C_BaseEntity::PopEnableAbsRecomputations();
		vecTargetPos = trace.endpos;
	}

	// Look directly at the target
	vecToTarget = vecCamTarget - vecTargetPos;
	VectorNormalize( vecToTarget );
	VectorAngles( vecToTarget, eyeAngles );

	VectorLerp( m_vecFreezeFrameStart, vecTargetPos, flBlendPerc, eyeOrigin );

	if ( flCurTime >= spec_freeze_traveltime.GetFloat() && !m_bSentFreezeFrame )
	{
		IGameEvent *pEvent = gameeventmanager->CreateEvent( "freezecam_started" );
		if ( pEvent )
		{
			gameeventmanager->FireEventClientSide( pEvent );
		}

		m_bSentFreezeFrame = true;
		view->FreezeFrame( spec_freeze_time.GetFloat() );
	}
}

const Vector& C_DODPlayer::GetRenderOrigin( void )
{
	if ( !IsAlive() && m_hRagdoll.Get() )
		return m_hRagdoll.Get()->GetRenderOrigin();

	return BaseClass::GetRenderOrigin();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
Vector C_DODPlayer::GetChaseCamViewOffset( CBaseEntity *target )
{
	C_DODPlayer *pPlayer = ToDODPlayer( target );

	if ( pPlayer && pPlayer->IsAlive() )
	{
		if ( pPlayer->m_Shared.IsProne() )
		{
			return VEC_PRONE_VIEW;
		}
	}

	return BaseClass::GetChaseCamViewOffset( target );
}

const QAngle& C_DODPlayer::EyeAngles()
{
	if ( IsLocalPlayer() && g_nKillCamMode == OBS_MODE_NONE )
	{
		return BaseClass::EyeAngles();
	}
	else
	{
		return m_angEyeAngles;
	}
}

// Cold breath defines.
#define COLDBREATH_EMIT_MIN				2.0f
#define COLDBREATH_EMIT_MAX				3.0f
#define COLDBREATH_EMIT_SCALE			0.35f
#define COLDBREATH_PARTICLE_LIFE_MIN	0.25f
#define COLDBREATH_PARTICLE_LIFE_MAX	1.0f
#define COLDBREATH_PARTICLE_LIFE_SCALE  0.75
#define COLDBREATH_PARTICLE_SIZE_MIN	1.0f
#define COLDBREATH_PARTICLE_SIZE_MAX	4.0f
#define COLDBREATH_PARTICLE_SIZE_SCALE	1.1f
#define COLDBREATH_PARTICLE_COUNT		1
#define COLDBREATH_DURATION_MIN			0.0f
#define COLDBREATH_DURATION_MAX			1.0f
#define COLDBREATH_ALPHA_MIN			0.0f
#define COLDBREATH_ALPHA_MAX			0.3f
#define COLDBREATH_ENDSCALE_MIN			0.1f
#define COLDBREATH_ENDSCALE_MAX			0.4f

static ConVar cl_coldbreath_forcestamina( "cl_coldbreath_forcestamina", "0", FCVAR_CHEAT );
static ConVar cl_coldbreath_enable( "cl_coldbreath_enable", "1" );

//-----------------------------------------------------------------------------
// Purpose: Create the emitter of cold breath particles
//-----------------------------------------------------------------------------
bool C_DODPlayer::CreateColdBreathEmitter( void )
{
	// Check to see if we are in a cold breath scenario.
	if ( !GetClientWorldEntity()->m_bColdWorld )
		return false;

	// Set cold breath to true.
	m_bColdBreathOn = true;

	// Create a cold breath emitter if one doesn't already exist.
	if ( !m_hColdBreathEmitter )
	{
		m_hColdBreathEmitter = ColdBreathEmitter::Create( "ColdBreath" );
		if ( !m_hColdBreathEmitter )
			return false;

		// Get the particle material.
		m_hColdBreathMaterial = m_hColdBreathEmitter->GetPMaterial( "sprites/frostbreath" );
		Assert( m_hColdBreathMaterial != INVALID_MATERIAL_HANDLE );

		// Cache off the head attachment for setting up cold breath.
		m_iHeadAttach = LookupAttachment( "head" );		
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Destroy the cold breath emitter
//-----------------------------------------------------------------------------
void C_DODPlayer::DestroyColdBreathEmitter( void )
{
#if 0
	if ( m_hColdBreathEmitter.IsValid() )
	{
		UTIL_Remove( m_hColdBreathEmitter );
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_DODPlayer::UpdateColdBreath( void )
{
	if ( !cl_coldbreath_enable.GetBool() )
		return;

	// Check to see if the cold breath emitter has been created.
	if ( !m_hColdBreathEmitter.IsValid() )
	{
		if ( !CreateColdBreathEmitter() )
			return;
	}

	// Cold breath updates.
	if ( !m_bColdBreathOn )
		return;

	// Don't emit breath if we are dead.
	if ( !IsAlive() || IsDormant() )
		return;

	// Check player speed, do emit cold breath when moving quickly.
	float flSpeed = GetAbsVelocity().Length();
	if ( flSpeed > 60.0f )
		return;

	if ( m_flColdBreathTimeStart < gpGlobals->curtime )
	{
		// Spawn cold breath particles.
		EmitColdBreathParticles();

		// Update the timer.
		if ( m_flColdBreathTimeEnd < gpGlobals->curtime )
		{
			// Check stamina and modify the time accordingly.
			if ( m_Shared.m_flStamina < LOW_STAMINA_THRESHOLD || cl_coldbreath_forcestamina.GetBool() )
			{
				m_flColdBreathTimeStart = gpGlobals->curtime + RandomFloat( COLDBREATH_EMIT_MIN * COLDBREATH_EMIT_SCALE, COLDBREATH_EMIT_MAX * COLDBREATH_EMIT_SCALE );
				float flDuration = RandomFloat( COLDBREATH_DURATION_MIN, COLDBREATH_DURATION_MAX );
				m_flColdBreathTimeEnd = m_flColdBreathTimeStart + flDuration;
			}
			else
			{
				m_flColdBreathTimeStart = gpGlobals->curtime + RandomFloat( COLDBREATH_EMIT_MIN, COLDBREATH_EMIT_MAX );
				float flDuration = RandomFloat( COLDBREATH_DURATION_MIN, COLDBREATH_DURATION_MAX );
				m_flColdBreathTimeEnd = m_flColdBreathTimeStart + flDuration;
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void C_DODPlayer::CalculateIKLocks( float currentTime )
{
	if (!m_pIk) 
		return;

	int targetCount = m_pIk->m_target.Count();
	if ( targetCount == 0 )
		return;

	// In TF, we might be attaching a player's view to a walking model that's using IK. If we are, it can
	// get in here during the view setup code, and it's not normally supposed to be able to access the spatial
	// partition that early in the rendering loop. So we allow access right here for that special case.
	SpatialPartitionListMask_t curSuppressed = partition->GetSuppressedLists();
	partition->SuppressLists( PARTITION_ALL_CLIENT_EDICTS, false );
	CBaseEntity::PushEnableAbsRecomputations( false );

	for (int i = 0; i < targetCount; i++)
	{
		trace_t trace;
		CIKTarget *pTarget = &m_pIk->m_target[i];

		if (!pTarget->IsActive())
			continue;

		switch( pTarget->type)
		{
		case IK_GROUND:
			{
				pTarget->SetPos( Vector( pTarget->est.pos.x, pTarget->est.pos.y, GetRenderOrigin().z ));
				pTarget->SetAngles( GetRenderAngles() );
			}
			break;

		case IK_ATTACHMENT:
			{
				C_BaseEntity *pEntity = NULL;
				float flDist = pTarget->est.radius;

				// FIXME: make entity finding sticky!
				// FIXME: what should the radius check be?
				for ( CEntitySphereQuery sphere( pTarget->est.pos, 64 ); ( pEntity = sphere.GetCurrentEntity() ) != NULL; sphere.NextEntity() )
				{
					C_BaseAnimating *pAnim = pEntity->GetBaseAnimating( );
					if (!pAnim)
						continue;

					int iAttachment = pAnim->LookupAttachment( pTarget->offset.pAttachmentName );
					if (iAttachment <= 0)
						continue;

					Vector origin;
					QAngle angles;
					pAnim->GetAttachment( iAttachment, origin, angles );

					// debugoverlay->AddBoxOverlay( origin, Vector( -1, -1, -1 ), Vector( 1, 1, 1 ), QAngle( 0, 0, 0 ), 255, 0, 0, 0, 0 );

					float d = (pTarget->est.pos - origin).Length();

					if ( d >= flDist)
						continue;

					flDist = d;
					pTarget->SetPos( origin );
					pTarget->SetAngles( angles );
					// debugoverlay->AddBoxOverlay( pTarget->est.pos, Vector( -pTarget->est.radius, -pTarget->est.radius, -pTarget->est.radius ), Vector( pTarget->est.radius, pTarget->est.radius, pTarget->est.radius), QAngle( 0, 0, 0 ), 0, 255, 0, 0, 0 );
				}

				if (flDist >= pTarget->est.radius)
				{
					// debugoverlay->AddBoxOverlay( pTarget->est.pos, Vector( -pTarget->est.radius, -pTarget->est.radius, -pTarget->est.radius ), Vector( pTarget->est.radius, pTarget->est.radius, pTarget->est.radius), QAngle( 0, 0, 0 ), 0, 0, 255, 0, 0 );
					// no solution, disable ik rule
					pTarget->IKFailed( );
				}
			}
			break;
		}
	}

	CBaseEntity::PopEnableAbsRecomputations();
	partition->SuppressLists( curSuppressed, true );
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_DODPlayer::EmitColdBreathParticles( void )
{
	// Get the position to emit from - look into caching this off we are doing redundant work in the case
	// of allies (see dod_headiconmanager.cpp).
	Vector vecOrigin; 
	QAngle vecAngle;
	GetAttachment( m_iHeadAttach, vecOrigin, vecAngle );
	Vector vecForward, vecRight, vecUp;
	AngleVectors( vecAngle, &vecUp, &vecForward, &vecRight );

	vecOrigin += ( vecForward * 8.0f );

	SimpleParticle *pParticle = static_cast<SimpleParticle*>( m_hColdBreathEmitter->AddParticle( sizeof( SimpleParticle ),m_hColdBreathMaterial, vecOrigin ) );
	if ( pParticle )
	{
		pParticle->m_flLifetime	= 0.0f;
		pParticle->m_flDieTime = RandomFloat( COLDBREATH_PARTICLE_LIFE_MIN, COLDBREATH_PARTICLE_LIFE_MAX );
		if ( m_Shared.m_flStamina < LOW_STAMINA_THRESHOLD || cl_coldbreath_forcestamina.GetBool() )
		{
			pParticle->m_flDieTime *= COLDBREATH_PARTICLE_LIFE_SCALE;
		}

		// Add just a little movement.
		if ( m_Shared.m_flStamina < LOW_STAMINA_THRESHOLD || cl_coldbreath_forcestamina.GetBool() )
		{
			pParticle->m_vecVelocity = ( vecForward * RandomFloat( 10.0f, 30.0f ) ) + ( vecRight * RandomFloat( -2.0f, 2.0f ) ) +
				                       ( vecUp * RandomFloat( 0.0f, 0.5f ) );
		}
		else
		{
			pParticle->m_vecVelocity = ( vecForward * RandomFloat( 10.0f, 20.0f ) ) + ( vecRight * RandomFloat( -2.0f, 2.0f ) ) +
				                       ( vecUp * RandomFloat( 0.0f, 1.5f ) );
		}
				
		pParticle->m_uchColor[0] = 200;
		pParticle->m_uchColor[1] = 200;
		pParticle->m_uchColor[2] = 210;
				
		float flParticleSize = RandomFloat( COLDBREATH_PARTICLE_SIZE_MIN, COLDBREATH_PARTICLE_SIZE_MAX );
		float flParticleScale = RandomFloat( COLDBREATH_ENDSCALE_MIN, COLDBREATH_ENDSCALE_MAX );
		if ( m_Shared.m_flStamina < LOW_STAMINA_THRESHOLD || cl_coldbreath_forcestamina.GetBool() )
		{
			pParticle->m_uchEndSize = flParticleSize * COLDBREATH_PARTICLE_SIZE_SCALE;
			flParticleScale *= COLDBREATH_PARTICLE_SIZE_SCALE;
		}
		else
		{
			pParticle->m_uchEndSize = flParticleSize;
		}
		pParticle->m_uchStartSize = ( flParticleSize * flParticleScale );
				
		float flAlpha = RandomFloat( COLDBREATH_ALPHA_MIN, COLDBREATH_ALPHA_MAX );
		pParticle->m_uchStartAlpha = flAlpha * 255; 
		pParticle->m_uchEndAlpha = 0;
				
		pParticle->m_flRoll	= RandomInt( 0, 360 );
		pParticle->m_flRollDelta = RandomFloat( 0.0f, 1.25f );
	}
}

void C_DODPlayer::ComputeWorldSpaceSurroundingBox( Vector *pVecWorldMins, Vector *pVecWorldMaxs )
{
	m_Shared.ComputeWorldSpaceSurroundingBox( pVecWorldMins, pVecWorldMaxs );
}

//-----------------------------------------------------------------------------
// Purpose: Try to steer away from any players and objects we might interpenetrate
//-----------------------------------------------------------------------------
#define DOD_AVOID_MAX_RADIUS_SQR		5184.0f			// Based on player extents and max buildable extents.
#define DOD_OO_AVOID_MAX_RADIUS_SQR		0.00019f

#define DOD_MAX_SEPARATION_FORCE		256

extern ConVar cl_forwardspeed;
extern ConVar cl_backspeed;
extern ConVar cl_sidespeed;

void C_DODPlayer::AvoidPlayers( CUserCmd *pCmd )
{
	// Don't test if the player is dead.
	if ( IsAlive() == false )
		return;

	C_Team *pTeam = ( C_Team * )GetTeam();
	if ( !pTeam )
		return;

	// Up vector.
	static Vector vecUp( 0.0f, 0.0f, 1.0f );

	Vector vecDODPlayerCenter = GetAbsOrigin();
	Vector vecDODPlayerMin = GetPlayerMins();
	Vector vecDODPlayerMax = GetPlayerMaxs();
	float flZHeight = vecDODPlayerMax.z - vecDODPlayerMin.z;
	vecDODPlayerCenter.z += 0.5f * flZHeight;
	VectorAdd( vecDODPlayerMin, vecDODPlayerCenter, vecDODPlayerMin );
	VectorAdd( vecDODPlayerMax, vecDODPlayerCenter, vecDODPlayerMax );

	// Find an intersecting player or object.
	int nAvoidPlayerCount = 0;
	C_DODPlayer *pAvoidPlayerList[MAX_PLAYERS];

	C_DODPlayer *pIntersectPlayer = NULL;
	float flAvoidRadius = 0.0f;

	Vector vecAvoidCenter, vecAvoidMin, vecAvoidMax;
	for ( int i = 0; i < pTeam->GetNumPlayers(); ++i )
	{
		C_DODPlayer *pAvoidPlayer = static_cast< C_DODPlayer * >( pTeam->GetPlayer( i ) );
		if ( pAvoidPlayer == NULL )
			continue;
		// Is the avoid player me?
		if ( pAvoidPlayer == this )
			continue;

		// Save as list to check against for objects.
		pAvoidPlayerList[nAvoidPlayerCount] = pAvoidPlayer;
		++nAvoidPlayerCount;

		// Check to see if the avoid player is dormant.
		if ( pAvoidPlayer->IsDormant() )
			continue;

		// Is the avoid player solid?
		if ( pAvoidPlayer->IsSolidFlagSet( FSOLID_NOT_SOLID ) )
			continue;

		Vector t1, t2;

		vecAvoidCenter = pAvoidPlayer->GetAbsOrigin();
		vecAvoidMin = pAvoidPlayer->GetPlayerMins();
		vecAvoidMax = pAvoidPlayer->GetPlayerMaxs();
		flZHeight = vecAvoidMax.z - vecAvoidMin.z;
		vecAvoidCenter.z += 0.5f * flZHeight;
		VectorAdd( vecAvoidMin, vecAvoidCenter, vecAvoidMin );
		VectorAdd( vecAvoidMax, vecAvoidCenter, vecAvoidMax );

		if ( IsBoxIntersectingBox( vecDODPlayerMin, vecDODPlayerMax, vecAvoidMin, vecAvoidMax ) )
		{
			// Need to avoid this player.
			if ( !pIntersectPlayer )
			{
				pIntersectPlayer = pAvoidPlayer;
				break;
			}
		}
	}

	// Anything to avoid?
	if ( !pIntersectPlayer )
	{
		return;
	}

	// Calculate the push strength and direction.
	Vector vecDelta;

	// Avoid a player - they have precedence.
	if ( pIntersectPlayer )
	{
		VectorSubtract( pIntersectPlayer->WorldSpaceCenter(), vecDODPlayerCenter, vecDelta );

		Vector vRad = pIntersectPlayer->WorldAlignMaxs() - pIntersectPlayer->WorldAlignMins();
		vRad.z = 0;

		flAvoidRadius = vRad.Length();
	}

	float flPushStrength = RemapValClamped( vecDelta.Length(), flAvoidRadius, 0, 0, DOD_MAX_SEPARATION_FORCE ); //flPushScale;

	//Msg( "PushScale = %f\n", flPushStrength );

	// Check to see if we have enough push strength to make a difference.
	if ( flPushStrength < 0.01f )
		return;

	Vector vecPush;
	if ( GetAbsVelocity().Length2DSqr() > 0.1f )
	{
		Vector vecVelocity = GetAbsVelocity();
		vecVelocity.z = 0.0f;
		CrossProduct( vecUp, vecVelocity, vecPush );
		VectorNormalize( vecPush );
	}
	else
	{
		// We are not moving, but we're still intersecting.
		QAngle angView = pCmd->viewangles;
		angView.x = 0.0f;
		AngleVectors( angView, NULL, &vecPush, NULL );
	}

	// Move away from the other player/object.
	Vector vecSeparationVelocity;
	if ( vecDelta.Dot( vecPush ) < 0 )
	{
		vecSeparationVelocity = vecPush * flPushStrength;
	}
	else
	{
		vecSeparationVelocity = vecPush * -flPushStrength;
	}

	// Don't allow the max push speed to be greater than the max player speed.
	float flMaxPlayerSpeed = MaxSpeed();
	float flCropFraction = 1.33333333f;

	if ( ( GetFlags() & FL_DUCKING ) && ( GetGroundEntity() != NULL ) )
	{	
		flMaxPlayerSpeed *= flCropFraction;
	}	

	float flMaxPlayerSpeedSqr = flMaxPlayerSpeed * flMaxPlayerSpeed;

	if ( vecSeparationVelocity.LengthSqr() > flMaxPlayerSpeedSqr )
	{
		vecSeparationVelocity.NormalizeInPlace();
		VectorScale( vecSeparationVelocity, flMaxPlayerSpeed, vecSeparationVelocity );
	}

	QAngle vAngles = pCmd->viewangles;
	vAngles.x = 0;
	Vector currentdir;
	Vector rightdir;

	AngleVectors( vAngles, &currentdir, &rightdir, NULL );

	Vector vDirection = vecSeparationVelocity;

	VectorNormalize( vDirection );

	float fwd = currentdir.Dot( vDirection );
	float rt = rightdir.Dot( vDirection );

	float forward = fwd * flPushStrength;
	float side = rt * flPushStrength;

	//Msg( "fwd: %f - rt: %f - forward: %f - side: %f\n", fwd, rt, forward, side );

	pCmd->forwardmove	+= forward;
	pCmd->sidemove		+= side;

	// Clamp the move to within legal limits, preserving direction. This is a little
	// complicated because we have different limits for forward, back, and side

	//Msg( "PRECLAMP: forwardmove=%f, sidemove=%f\n", pCmd->forwardmove, pCmd->sidemove );

	float flForwardScale = 1.0f;
	if ( pCmd->forwardmove > fabs( cl_forwardspeed.GetFloat() ) )
	{
		flForwardScale = fabs( cl_forwardspeed.GetFloat() ) / pCmd->forwardmove;
	}
	else if ( pCmd->forwardmove < -fabs( cl_backspeed.GetFloat() ) )
	{
		flForwardScale = fabs( cl_backspeed.GetFloat() ) / fabs( pCmd->forwardmove );
	}

	float flSideScale = 1.0f;
	if ( fabs( pCmd->sidemove ) > fabs( cl_sidespeed.GetFloat() ) )
	{
		flSideScale = fabs( cl_sidespeed.GetFloat() ) / fabs( pCmd->sidemove );
	}

	float flScale = MIN( flForwardScale, flSideScale );
	pCmd->forwardmove *= flScale;
	pCmd->sidemove *= flScale;

	//Msg( "Pforwardmove=%f, sidemove=%f\n", pCmd->forwardmove, pCmd->sidemove );
}


//-----------------------------------------------------------------------------
// Purpose: Returns whether this player is the nemesis of the local player
//-----------------------------------------------------------------------------
bool C_DODPlayer::IsNemesisOfLocalPlayer()
{
	C_DODPlayer *pLocalPlayer = C_DODPlayer::GetLocalDODPlayer();
	if ( pLocalPlayer )
	{
		// return whether this player is dominating the local player
		return m_Shared.IsPlayerDominated( pLocalPlayer->entindex() );
	}		
	return false;
}

//-----------------------------------------------------------------------------
// Purpose: Returns whether we should show the nemesis icon for this player
//-----------------------------------------------------------------------------
bool C_DODPlayer::ShouldShowNemesisIcon()
{
	/*
	// we should show the nemesis effect on this player if he is the nemesis of the local player,
	// and is not dead, cloaked or disguised
	if ( IsNemesisOfLocalPlayer() && g_DODPR && g_PR->IsConnected( entindex() ) )
	{
		if ( IsAlive() )
			return true;
	}
	*/
	return false;
}

int C_DODPlayer::GetActiveAchievementAward( void )
{
	int iAward = ACHIEVEMENT_AWARDS_NONE;

	int iClassBit = m_Shared.PlayerClass() + 1;

	if ( m_iAchievementAwardsMask & (1<<ACHIEVEMENT_AWARDS_ALL_PACK_1) )
	{
		iAward = ACHIEVEMENT_AWARDS_ALL_PACK_1;
	}
	else if ( m_iAchievementAwardsMask & ( 1<<iClassBit ) )
	{
		iAward = iClassBit;
	}

	return iAward;
}

IMaterial *C_DODPlayer::GetHeadIconMaterial( void )
{
	const char *pszMaterial = "";

	int iAchievementAward = GetActiveAchievementAward();

	if ( iAchievementAward >= 0 && iAchievementAward < NUM_ACHIEVEMENT_AWARDS )
	{
		switch ( GetTeamNumber() )
		{
		case TEAM_ALLIES:
			pszMaterial = g_pszAchievementAwardMaterials_Allies[iAchievementAward];
			break;
		case TEAM_AXIS:
			pszMaterial = g_pszAchievementAwardMaterials_Axis[iAchievementAward];
			break;
		default:
			break;
		}
	}

	IMaterial *pMaterial = NULL;
	if ( pszMaterial )
	{
		pMaterial = materials->FindMaterial( pszMaterial, TEXTURE_GROUP_VGUI );
	}	

	// clear the old one if its different
	if ( m_pHeadIconMaterial != pMaterial )
	{
		if ( m_pHeadIconMaterial )
		{
			m_pHeadIconMaterial->DecrementReferenceCount();
		}

		m_pHeadIconMaterial = pMaterial;
		m_pHeadIconMaterial->IncrementReferenceCount();
	}

	return m_pHeadIconMaterial;
}