1HEADmaster

1 files changed, 1396 insertions, 0 deletions

diff --git a/game/shared/dod/dod_player_shared.cpp b/game/shared/dod/dod_player_shared.cpp
new file mode 100644
index 0000000..ec35acf
--- /dev/null
+++ b/game/shared/dod/dod_player_shared.cpp
@@ -0,0 +1,1396 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "dod_gamerules.h"
+#include "takedamageinfo.h"
+#include "dod_shareddefs.h"
+#include "effect_dispatch_data.h"
+
+#include "weapon_dodbase.h"
+#include "weapon_dodbipodgun.h"
+#include "weapon_dodbaserpg.h"
+#include "weapon_dodsniper.h"
+
+#include "movevars_shared.h"
+#include "engine/IEngineSound.h"
+#include "SoundEmitterSystem/isoundemittersystembase.h"
+#include "engine/ivdebugoverlay.h"
+#include "obstacle_pushaway.h"
+#include "props_shared.h"
+
+#include "decals.h"
+#include "util_shared.h"
+
+#ifdef CLIENT_DLL
+	
+	#include "c_dod_player.h"
+	#include "prediction.h"
+	#include "clientmode_dod.h"
+	#include "vgui_controls/AnimationController.h"
+
+	#define CRecipientFilter C_RecipientFilter
+
+#else
+
+	#include "dod_player.h"
+
+#endif
+
+ConVar dod_bonusround( "dod_bonusround", "1", FCVAR_REPLICATED, "If true, the winners of the round can attack in the intermission." );
+ConVar sv_showimpacts("sv_showimpacts", "0", FCVAR_REPLICATED | FCVAR_CHEAT, "Shows client (red) and server (blue) bullet impact point" );
+
+void DispatchEffect( const char *pName, const CEffectData &data );
+
+bool CDODPlayer::CanMove( void ) const
+{
+	bool bValidMoveState = (State_Get() == STATE_ACTIVE || State_Get() == STATE_OBSERVER_MODE);
+			
+	if ( !bValidMoveState )
+	{
+		return false;
+	}
+
+	return true;
+}
+
+// BUG! This is not called on the client at respawn, only first spawn!
+void CDODPlayer::SharedSpawn()
+{	
+	BaseClass::SharedSpawn();
+
+	// Reset the animation state or we will animate to standing
+	// when we spawn
+
+	m_Shared.SetJumping( false );
+
+	m_flMinNextStepSoundTime = gpGlobals->curtime;
+
+	m_bPlayingProneMoveSound = false;
+}
+
+float GetDensityFromMaterial( surfacedata_t *pSurfaceData )
+{
+	float flMaterialMod = 1.0f;
+
+	Assert( pSurfaceData );
+
+	// material mod is how many points of damage it costs to go through
+	// 1 unit of the material
+
+	switch( pSurfaceData->game.material )
+	{
+	//super soft
+//	case CHAR_TEX_LEAVES:
+//		flMaterialMod = 1.2f;
+//		break;
+
+	case CHAR_TEX_FLESH:
+		flMaterialMod = 1.35f;
+		break;
+
+	//soft
+//	case CHAR_TEX_STUCCO:
+//	case CHAR_TEX_SNOW:
+	case CHAR_TEX_GLASS:
+	case CHAR_TEX_WOOD:
+	case CHAR_TEX_TILE:
+		flMaterialMod = 1.8f;
+		break;
+
+	//hard
+//	case CHAR_TEX_SKY:
+//	case CHAR_TEX_ROCK:
+//	case CHAR_TEX_SAND:	
+	case CHAR_TEX_CONCRETE:
+	case CHAR_TEX_DIRT:		// "sand"
+		flMaterialMod = 6.6f;
+		break;
+
+	//really hard
+//	case CHAR_TEX_HEAVYMETAL:
+	case CHAR_TEX_GRATE:
+	case CHAR_TEX_METAL:
+		flMaterialMod = 13.5f;
+		break;
+
+	case 'X':		// invisible collision material
+		flMaterialMod = 0.1f;
+		break;
+
+	//medium
+//	case CHAR_TEX_BRICK:
+//	case CHAR_TEX_GRAVEL:
+//	case CHAR_TEX_GRASS:
+	default:
+
+#ifndef CLIENT_DLL
+		AssertMsg( 0, UTIL_VarArgs( "Material has unknown materialmod - '%c' \n", pSurfaceData->game.material ) );
+#endif
+
+		flMaterialMod = 5.0f;
+		break;
+	}
+
+	Assert( flMaterialMod > 0 );
+
+	return flMaterialMod;
+}
+
+static bool TraceToExit( const Vector &start,
+						const Vector &dir,
+						Vector &end,
+						const float flStepSize,
+						const float flMaxDistance )
+{
+	float flDistance = 0;
+	Vector last = start;
+
+	while ( flDistance < flMaxDistance )
+	{
+		flDistance += flStepSize;
+
+		// no point in tracing past the max distance.
+		// if this check fails, we save ourselves a traceline later
+		if ( flDistance > flMaxDistance )
+		{
+			flDistance = flMaxDistance;
+		}
+
+		end = start + flDistance * dir; 
+
+		// point contents fails to return proper contents inside a func_detail brush, eg the dod_flash 
+		// stairs
+
+		//int contents = UTIL_PointContents( end );
+
+		trace_t tr;
+		UTIL_TraceLine( end, end, MASK_SOLID | CONTENTS_HITBOX, NULL, &tr );
+
+		//if ( (UTIL_PointContents ( end ) & MASK_SOLID) == 0 )
+
+		if ( !tr.startsolid )
+		{
+			// found first free point
+			return true;
+		}
+	}
+
+	return false;
+}
+
+#include "ammodef.h"
+
+#define NEW_HITBOX_GROUP_CODE 1
+#undef ARM_PENETRATION
+
+#ifndef CLIENT_DLL
+#include "ndebugoverlay.h"
+#endif
+void CDODPlayer::FireBullets( const FireBulletsInfo_t &info )
+{
+	trace_t			tr;								
+	trace_t			reverseTr;						//Used to find exit points
+	static int		iMaxPenetrations	= 6;
+	int				iPenetrations		= 0;
+	float			flDamage			= info.m_flDamage;		//Remaining damage in the bullet
+	Vector			vecSrc				= info.m_vecSrc;
+	Vector			vecEnd				= vecSrc + info.m_vecDirShooting * info.m_flDistance;
+
+	static int		iTraceMask = ( ( MASK_SOLID | CONTENTS_DEBRIS | CONTENTS_HITBOX | CONTENTS_PRONE_HELPER ) & ~CONTENTS_GRATE );
+	 
+	CBaseEntity		*pLastHitEntity		= this;	// start with us so we don't trace ourselves
+		
+	int iDamageType = GetAmmoDef()->DamageType( info.m_iAmmoType );
+	int iCollisionGroup = COLLISION_GROUP_NONE;
+
+#ifdef GAME_DLL
+	int iNumHeadshots = 0;
+#endif
+
+	while ( flDamage > 0 && iPenetrations < iMaxPenetrations )
+	{
+		//DevMsg( 2, "penetration: %d, starting dmg: %.1f\n", iPenetrations, flDamage );
+
+		CBaseEntity *pPreviousHit = pLastHitEntity;
+
+		// skip the shooter always
+		CTraceFilterSkipTwoEntities ignoreShooterAndPrevious( this, pPreviousHit, iCollisionGroup );
+		UTIL_TraceLine( vecSrc, vecEnd, iTraceMask, &ignoreShooterAndPrevious, &tr );
+
+		const float rayExtension = 40.0f;
+		UTIL_ClipTraceToPlayers( vecSrc, vecEnd + info.m_vecDirShooting * rayExtension, iTraceMask, &ignoreShooterAndPrevious, &tr );
+
+		if ( tr.fraction == 1.0f )
+			break; // we didn't hit anything, stop tracing shoot
+
+		// New hitbox code that uses hitbox groups instead of trying to trace
+		// through the player
+		if ( tr.m_pEnt && tr.m_pEnt->IsPlayer() )
+		{
+			switch( tr.hitgroup )
+			{
+#ifdef GAME_DLL
+			case HITGROUP_HEAD:
+				{
+					if ( tr.m_pEnt->GetTeamNumber() != GetTeamNumber() )
+					{
+						iNumHeadshots++;
+					}
+				}
+				break;
+#endif
+
+			case HITGROUP_LEFTARM:
+			case HITGROUP_RIGHTARM:
+				{
+					//DevMsg( 2, "Hit arms, tracing against alt hitboxes.. \n" );
+
+					CDODPlayer *pPlayer = ToDODPlayer( tr.m_pEnt );
+
+					// set hitbox set to "dod_no_arms"
+					pPlayer->SetHitboxSet( 1 );
+
+					trace_t newTr;
+
+					// re-fire the trace
+					UTIL_TraceLine( vecSrc, vecEnd, iTraceMask, &ignoreShooterAndPrevious, &newTr );
+
+					// if we hit the same player in the chest
+					if ( tr.m_pEnt == newTr.m_pEnt )
+					{
+						//DevMsg( 2, ".. and we hit the chest.\n" );
+
+						Assert( tr.hitgroup != newTr.hitgroup );	// If we hit this, hitbox sets are broken
+
+						// use that damage instead
+						tr = newTr;
+					}
+
+					// set hitboxes back to "dod"
+					pPlayer->SetHitboxSet( 0 );
+				}
+				break;
+
+			default:
+				break;
+			}			
+		}
+			
+		pLastHitEntity = tr.m_pEnt;
+
+		if ( sv_showimpacts.GetBool() )
+		{
+#ifdef CLIENT_DLL
+			// draw red client impact markers
+			debugoverlay->AddBoxOverlay( tr.endpos, Vector(-1,-1,-1), Vector(1,1,1), QAngle(0,0,0), 255, 0, 0, 127, 4 );
+
+			if ( tr.m_pEnt && tr.m_pEnt->IsPlayer() )
+			{
+				C_BasePlayer *player = ToBasePlayer( tr.m_pEnt );
+				player->DrawClientHitboxes( 4, true );
+			}
+#else
+			// draw blue server impact markers
+			NDebugOverlay::Box( tr.endpos, Vector(-1,-1,-1), Vector(1,1,1), 0,0,255,127, 4 );
+
+			if ( tr.m_pEnt && tr.m_pEnt->IsPlayer() )
+			{
+				CBasePlayer *player = ToBasePlayer( tr.m_pEnt );
+				player->DrawServerHitboxes( 4, true );
+			}
+#endif
+		}
+
+#ifdef CLIENT_DLL
+		// See if the bullet ended up underwater + started out of the water
+		if ( enginetrace->GetPointContents( tr.endpos ) & (CONTENTS_WATER|CONTENTS_SLIME) )
+		{	
+			trace_t waterTrace;
+			UTIL_TraceLine( vecSrc, tr.endpos, (MASK_SHOT|CONTENTS_WATER|CONTENTS_SLIME), this, iCollisionGroup, &waterTrace );
+			
+			if( waterTrace.allsolid != 1 )
+			{
+				CEffectData	data;
+ 				data.m_vOrigin = waterTrace.endpos;
+				data.m_vNormal = waterTrace.plane.normal;
+				data.m_flScale = random->RandomFloat( 8, 12 );
+
+				if ( waterTrace.contents & CONTENTS_SLIME )
+				{
+					data.m_fFlags |= FX_WATER_IN_SLIME;
+				}
+
+				DispatchEffect( "gunshotsplash", data );
+			}
+		}
+		else
+		{
+			//Do Regular hit effects
+
+			// Don't decal nodraw surfaces
+			if ( !( tr.surface.flags & (SURF_SKY|SURF_NODRAW|SURF_HINT|SURF_SKIP) ) )
+			{
+				CBaseEntity *pEntity = tr.m_pEnt;
+				if ( !( !friendlyfire.GetBool() && pEntity && pEntity->GetTeamNumber() == GetTeamNumber() ) )
+				{
+					UTIL_ImpactTrace( &tr, iDamageType );
+				}
+			}
+		}
+#endif
+
+		// Get surface where the bullet entered ( if it had different surfaces on enter and exit )
+		surfacedata_t *pSurfaceData = physprops->GetSurfaceData( tr.surface.surfaceProps );
+		Assert( pSurfaceData );
+		
+		float flMaterialMod = GetDensityFromMaterial(pSurfaceData);
+
+		if ( iDamageType & DMG_MACHINEGUN )
+		{
+			flMaterialMod *= 0.65;
+		}
+
+		// try to penetrate object
+		Vector penetrationEnd;
+		float flMaxDistance = flDamage / flMaterialMod;
+
+#ifndef CLIENT_DLL
+		ClearMultiDamage();
+
+		float flActualDamage = flDamage;
+
+		CTakeDamageInfo dmgInfo( info.m_pAttacker, info.m_pAttacker, flActualDamage, iDamageType );
+		CalculateBulletDamageForce( &dmgInfo, info.m_iAmmoType, info.m_vecDirShooting, tr.endpos );
+		tr.m_pEnt->DispatchTraceAttack( dmgInfo, info.m_vecDirShooting, &tr );
+
+		DevMsg( 2, "Giving damage ( %.1f ) to entity of type %s\n", flActualDamage, tr.m_pEnt->GetClassname() );
+
+		TraceAttackToTriggers( dmgInfo, tr.startpos, tr.endpos, info.m_vecDirShooting );
+#endif
+
+		int stepsize = 16;
+
+		// displacement always stops the bullet
+		if ( tr.IsDispSurface() )
+		{
+			DevMsg( 2, "bullet was stopped by displacement\n" );
+			ApplyMultiDamage();
+			break;
+		}
+
+		// trace through the solid to find the exit point and how much material we went through
+		if ( !TraceToExit( tr.endpos, info.m_vecDirShooting, penetrationEnd, stepsize, flMaxDistance ) )
+		{
+			DevMsg( 2, "bullet was stopped\n" );
+			ApplyMultiDamage();
+			break;
+		}
+
+		// find exact penetration exit
+		CTraceFilterSimple ignoreShooter( this, iCollisionGroup );
+		UTIL_TraceLine( penetrationEnd, tr.endpos, iTraceMask, &ignoreShooter, &reverseTr );
+
+		// Now we can apply the damage, after we have traced the entity
+		// so it doesn't break or die before we have a change to test against it
+#ifndef CLIENT_DLL
+		ApplyMultiDamage();
+#endif
+
+		// Continue looking for the exit point
+		if( reverseTr.m_pEnt != tr.m_pEnt && reverseTr.m_pEnt != NULL )
+		{
+			// something was blocking, trace again
+			CTraceFilterSkipTwoEntities ignoreShooterAndBlocker( this, reverseTr.m_pEnt, iCollisionGroup );
+			UTIL_TraceLine( penetrationEnd, tr.endpos, iTraceMask, &ignoreShooterAndBlocker, &reverseTr );
+		}
+
+		if ( sv_showimpacts.GetBool() )
+		{
+			debugoverlay->AddLineOverlay( penetrationEnd, reverseTr.endpos, 255, 0, 0, true, 3.0 );
+		}
+
+		// penetration was successful
+
+#ifdef CLIENT_DLL
+		// bullet did penetrate object, exit Decal
+		if ( !( reverseTr.surface.flags & (SURF_SKY|SURF_NODRAW|SURF_HINT|SURF_SKIP) ) )
+		{
+			CBaseEntity *pEntity = reverseTr.m_pEnt;
+			if ( !( !friendlyfire.GetBool() && pEntity && pEntity->GetTeamNumber() == GetTeamNumber() ) )
+			{
+				UTIL_ImpactTrace( &reverseTr, iDamageType );
+			}
+		}
+#endif
+
+		//setup new start end parameters for successive trace
+
+		// New start point is our last exit point
+		vecSrc = reverseTr.endpos + /* 1.0 * */ info.m_vecDirShooting;
+
+		// Reduce bullet damage by material and distanced travelled through that material
+		// if it is < 0 we won't go through the loop again
+		float flTraceDistance = VectorLength( reverseTr.endpos - tr.endpos );
+		
+		flDamage -= flMaterialMod * flTraceDistance;
+
+		if( flDamage > 0 )
+		{
+			DevMsg( 2, "Completed penetration, new damage is %.1f\n", flDamage );
+		}
+		else
+		{
+			DevMsg( 2, "bullet was stopped\n" );
+		}
+
+		iPenetrations++;
+	}
+
+#ifdef GAME_DLL
+	HandleHeadshotAchievement( iNumHeadshots );
+#endif
+}
+
+void CDODPlayer::SetSprinting( bool bIsSprinting )
+{
+	m_Shared.SetSprinting( bIsSprinting );
+}
+
+bool CDODPlayer::IsSprinting( void )
+{
+	float flVelSqr = GetAbsVelocity().LengthSqr();
+
+	return m_Shared.m_bIsSprinting && ( flVelSqr > 0.5f );
+}
+
+bool CDODPlayer::CanAttack( void )
+{
+	if ( IsSprinting() ) 
+		return false;
+
+	if ( GetMoveType() == MOVETYPE_LADDER )
+		return false;
+
+	if ( m_Shared.IsJumping() )
+		return false;
+
+	if ( m_Shared.IsDefusing() )
+		return false;
+
+	// cannot attack while prone moving. except if you have a bazooka
+	if ( m_Shared.IsProne() && GetAbsVelocity().LengthSqr() > 1 )
+	{
+		return false;
+	}
+
+	if( m_Shared.IsGoingProne() || m_Shared.IsGettingUpFromProne() )
+	{
+		return false;
+	}
+
+	CDODGameRules *rules = DODGameRules();
+
+	Assert( rules );
+
+	DODRoundState state = rules->State_Get();
+
+	if ( dod_bonusround.GetBool() )
+	{
+		if ( GetTeamNumber() == TEAM_ALLIES )
+		{ 
+			return ( state == STATE_RND_RUNNING || state == STATE_ALLIES_WIN );
+		}
+		else
+		{
+			return ( state == STATE_RND_RUNNING || state == STATE_AXIS_WIN );
+		}
+	}
+	else
+        return ( state == STATE_RND_RUNNING );
+}
+
+
+void CDODPlayer::SetAnimation( PLAYER_ANIM playerAnim )
+{
+	// In DoD, its CPlayerAnimState object manages ALL the animation state.
+	return;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : 
+// Output : const Vector
+//-----------------------------------------------------------------------------
+const Vector CDODPlayer::GetPlayerMins( void ) const
+{
+	if ( IsObserver() )
+	{
+		return VEC_OBS_HULL_MIN;	
+	}
+	else
+	{
+		if ( GetFlags() & FL_DUCKING )
+		{
+			return VEC_DUCK_HULL_MIN;
+		}
+		else if ( m_Shared.IsProne() )
+		{
+			return VEC_PRONE_HULL_MIN;
+		}
+		else
+		{
+			return VEC_HULL_MIN;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : 
+// Output : const Vector
+//-----------------------------------------------------------------------------
+const Vector CDODPlayer::GetPlayerMaxs( void ) const
+{	
+	if ( IsObserver() )
+	{
+		return VEC_OBS_HULL_MAX_SCALED( this );	
+	}
+	else
+	{
+		if ( GetFlags() & FL_DUCKING )
+		{
+			return VEC_DUCK_HULL_MAX_SCALED( this );
+		}
+		else if ( m_Shared.IsProne() )
+		{
+			return VEC_PRONE_HULL_MAX_SCALED( this );
+		}
+		else
+		{
+			return VEC_HULL_MAX_SCALED( this );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : collisionGroup - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CDODPlayer::ShouldCollide( int collisionGroup, int contentsMask ) const
+{
+	if ( collisionGroup == COLLISION_GROUP_PLAYER_MOVEMENT || collisionGroup == COLLISION_GROUP_PROJECTILE )
+	{
+		switch( GetTeamNumber() )
+		{
+		case TEAM_ALLIES:
+			if ( !( contentsMask & CONTENTS_TEAM2 ) )
+				return false;
+			break;
+
+		case TEAM_AXIS:
+			if ( !( contentsMask & CONTENTS_TEAM1 ) )
+				return false;
+			break;
+		}
+	}
+
+	return BaseClass::ShouldCollide( collisionGroup, contentsMask );
+}
+
+// --------------------------------------------------------------------------------------------------- //
+// CDODPlayerShared implementation.
+// --------------------------------------------------------------------------------------------------- //
+
+CDODPlayerShared::CDODPlayerShared()
+{
+	m_bProne = false;
+	m_bForceProneChange = false;
+	m_flNextProneCheck = 0;
+
+	m_flSlowedUntilTime = 0;
+
+	m_flUnProneTime = 0;
+	m_flGoProneTime = 0;
+
+	m_flDeployedHeight = STANDING_DEPLOY_HEIGHT;
+	m_flDeployChangeTime = gpGlobals->curtime;
+	
+	SetDesiredPlayerClass( PLAYERCLASS_UNDEFINED );
+
+	m_flLastViewAnimationTime = gpGlobals->curtime;
+
+	m_pViewOffsetAnim = NULL;
+}
+
+CDODPlayerShared::~CDODPlayerShared()
+{
+	if ( m_pViewOffsetAnim )
+	{
+		delete m_pViewOffsetAnim;
+		m_pViewOffsetAnim = NULL;
+	}
+}
+
+void CDODPlayerShared::Init( CDODPlayer *pPlayer )
+{
+	m_pOuter = pPlayer;
+}
+
+bool CDODPlayerShared::IsDucking( void ) const
+{
+	return !!( m_pOuter->GetFlags() & FL_DUCKING );
+}
+
+bool CDODPlayerShared::IsProne() const
+{
+	return m_bProne;
+}
+
+bool CDODPlayerShared::IsGettingUpFromProne() const
+{
+	return ( m_flUnProneTime > 0 );
+}
+
+bool CDODPlayerShared::IsGoingProne() const
+{
+	return ( m_flGoProneTime > 0 );
+}
+
+void CDODPlayerShared::SetSprinting( bool bSprinting )
+{
+	if ( bSprinting && !m_bIsSprinting )
+	{
+		StartSprinting();
+
+		// only one penalty per key press
+		if ( m_bGaveSprintPenalty == false )
+		{
+			m_flStamina -= INITIAL_SPRINT_STAMINA_PENALTY;
+			m_bGaveSprintPenalty = true;
+		}
+	}
+	else if ( !bSprinting && m_bIsSprinting )
+	{
+		StopSprinting();
+	}
+}
+
+// this is reset when we let go of the sprint key
+void CDODPlayerShared::ResetSprintPenalty( void )
+{
+	m_bGaveSprintPenalty = false;
+}
+
+void CDODPlayerShared::StartSprinting( void )
+{
+	m_bIsSprinting = true;
+
+#ifndef CLIENT_DLL
+	m_pOuter->RemoveHintTimer( HINT_USE_SPRINT );
+#endif
+}
+
+void CDODPlayerShared::StopSprinting( void )
+{
+	m_bIsSprinting = false;
+}
+
+void CDODPlayerShared::SetProne( bool bProne, bool bNoAnimation /* = false */ )
+{
+	m_bProne = bProne;
+
+	if ( bNoAnimation )
+	{
+		m_flGoProneTime = 0;
+		m_flUnProneTime = 0;
+
+		// cancel the view animation!
+		m_bForceProneChange = true;
+	}
+
+	if ( !bProne /*&& IsSniperZoomed()*/ )	// forceunzoom for going prone is in StartGoingProne
+	{
+		ForceUnzoom();
+	}
+}
+
+void CDODPlayerShared::SetJumping( bool bJumping )
+{
+	m_bJumping = bJumping;
+	
+	if ( IsSniperZoomed() )
+	{
+		ForceUnzoom();
+	}
+}
+
+void CDODPlayerShared::ForceUnzoom( void )
+{
+	CWeaponDODBase *pWeapon = GetActiveDODWeapon();
+	if( pWeapon && ( pWeapon->GetDODWpnData().m_WeaponType & WPN_MASK_GUN ) )
+	{
+		CDODSniperWeapon *pSniper = dynamic_cast<CDODSniperWeapon *>(pWeapon);
+
+		if ( pSniper )
+		{
+			pSniper->ZoomOut();
+		}
+	}
+}
+
+bool CDODPlayerShared::IsBazookaDeployed( void ) const
+{
+	CWeaponDODBase *pWeapon = GetActiveDODWeapon();
+	if( pWeapon && pWeapon->GetDODWpnData().m_WeaponType == WPN_TYPE_BAZOOKA )
+	{
+		CDODBaseRocketWeapon *pBazooka = (CDODBaseRocketWeapon *)pWeapon;
+		return pBazooka->IsDeployed() && !pBazooka->m_bInReload;
+	}
+
+	return false;
+}
+
+bool CDODPlayerShared::IsBazookaOnlyDeployed( void ) const
+{
+	CWeaponDODBase *pWeapon = GetActiveDODWeapon();
+	if( pWeapon && pWeapon->GetDODWpnData().m_WeaponType == WPN_TYPE_BAZOOKA )
+	{
+		CDODBaseRocketWeapon *pBazooka = (CDODBaseRocketWeapon *)pWeapon;
+		return pBazooka->IsDeployed();
+	}
+
+	return false;
+}
+
+bool CDODPlayerShared::IsSniperZoomed( void ) const
+{
+	CWeaponDODBase *pWeapon = GetActiveDODWeapon();
+	if( pWeapon && ( pWeapon->GetDODWpnData().m_WeaponType & WPN_MASK_GUN ) )
+	{
+		CWeaponDODBaseGun *pGun = (CWeaponDODBaseGun *)pWeapon;
+		Assert( pGun );
+		return pGun->IsSniperZoomed();
+	}
+
+	return false;
+}
+
+bool CDODPlayerShared::IsInMGDeploy( void ) const
+{
+	CWeaponDODBase *pWeapon = GetActiveDODWeapon();
+	if( pWeapon && pWeapon->GetDODWpnData().m_WeaponType == WPN_TYPE_MG )
+	{
+		CDODBipodWeapon *pMG = dynamic_cast<CDODBipodWeapon *>( pWeapon );
+		Assert( pMG );
+		return pMG->IsDeployed();
+	}
+
+	return false;
+}
+
+bool CDODPlayerShared::IsProneDeployed( void ) const
+{
+	return ( IsProne() && IsInMGDeploy() );
+}
+
+bool CDODPlayerShared::IsSandbagDeployed( void ) const
+{
+	return ( !IsProne() && IsInMGDeploy() );
+}
+
+void CDODPlayerShared::SetDesiredPlayerClass( int playerclass )
+{
+	m_iDesiredPlayerClass = playerclass;
+}
+
+int CDODPlayerShared::DesiredPlayerClass( void )
+{
+	return m_iDesiredPlayerClass;
+}
+
+void CDODPlayerShared::SetPlayerClass( int playerclass )
+{
+	m_iPlayerClass = playerclass;
+}
+
+int CDODPlayerShared::PlayerClass( void )
+{
+	return m_iPlayerClass;
+}
+
+void CDODPlayerShared::SetStamina( float flStamina )
+{
+	m_flStamina = clamp( flStamina, 0, 100 );
+}
+
+CWeaponDODBase* CDODPlayerShared::GetActiveDODWeapon() const
+{
+	CBaseCombatWeapon *pWeapon = m_pOuter->GetActiveWeapon();
+	if ( pWeapon )
+	{
+		Assert( dynamic_cast< CWeaponDODBase* >( pWeapon ) == static_cast< CWeaponDODBase* >( pWeapon ) );
+		return static_cast< CWeaponDODBase* >( pWeapon );
+	}
+	else
+	{
+		return NULL;
+	}
+}
+
+void CDODPlayerShared::SetDeployed( bool bDeployed, float flHeight /* = -1 */ )
+{
+	if( gpGlobals->curtime - m_flDeployChangeTime < 0.2 )
+	{
+		Assert(0);
+	}
+
+	m_flDeployChangeTime = gpGlobals->curtime;
+	m_vecDeployedAngles = m_pOuter->EyeAngles();
+
+	if( flHeight > 0 )
+	{
+		m_flDeployedHeight = flHeight;
+	}
+	else
+	{
+		m_flDeployedHeight = m_pOuter->GetViewOffset()[2];
+	}
+}
+
+QAngle CDODPlayerShared::GetDeployedAngles( void ) const
+{
+	return m_vecDeployedAngles;
+}
+
+void CDODPlayerShared::SetDeployedYawLimits( float flLeftYaw, float flRightYaw )
+{
+	m_flDeployedYawLimitLeft = flLeftYaw;
+	m_flDeployedYawLimitRight = -flRightYaw;
+
+	m_vecDeployedAngles = m_pOuter->EyeAngles();
+}
+
+void CDODPlayerShared::ClampDeployedAngles( QAngle *vecTestAngles )
+{
+	Assert( vecTestAngles );
+
+	// Clamp Pitch
+	vecTestAngles->x = clamp( vecTestAngles->x, MAX_DEPLOY_PITCH, MIN_DEPLOY_PITCH );
+
+	// Clamp Yaw - do a bit more work as yaw will wrap around and cause problems
+	float flDeployedYawCenter = GetDeployedAngles().y;
+
+	float flDelta = AngleNormalize( vecTestAngles->y - flDeployedYawCenter );
+
+	if( flDelta < m_flDeployedYawLimitRight )
+	{
+		vecTestAngles->y = flDeployedYawCenter + m_flDeployedYawLimitRight;
+	}
+	else if( flDelta > m_flDeployedYawLimitLeft )
+	{
+		vecTestAngles->y = flDeployedYawCenter + m_flDeployedYawLimitLeft;
+	}
+
+	/*
+	Msg( "delta %.1f ( left %.1f, right %.1f ) ( %.1f -> %.1f )\n",
+		flDelta,
+		flDeployedYawCenter + m_flDeployedYawLimitLeft,
+		flDeployedYawCenter + m_flDeployedYawLimitRight,
+		before,
+		vecTestAngles->y );
+		*/
+
+}
+
+float CDODPlayerShared::GetDeployedHeight( void ) const
+{
+	return m_flDeployedHeight;
+}
+
+float CDODPlayerShared::GetSlowedTime( void ) const
+{
+	return m_flSlowedUntilTime;
+}
+
+void CDODPlayerShared::SetSlowedTime( float t )
+{
+	m_flSlowedUntilTime = gpGlobals->curtime + t;
+}
+
+void CDODPlayerShared::StartGoingProne( void )
+{
+	// make the prone sound
+	CPASFilter filter( m_pOuter->GetAbsOrigin() );
+	filter.UsePredictionRules();
+	m_pOuter->EmitSound( filter, m_pOuter->entindex(), "Player.GoProne" );
+
+	// slow to prone speed
+	m_flGoProneTime = gpGlobals->curtime + TIME_TO_PRONE;
+
+	m_flUnProneTime = 0.0f;	//reset
+
+	if ( IsSniperZoomed() )
+		ForceUnzoom();
+}
+
+void CDODPlayerShared::StandUpFromProne( void )
+{	
+	// make the prone sound
+	CPASFilter filter( m_pOuter->GetAbsOrigin() );
+	filter.UsePredictionRules();
+	m_pOuter->EmitSound( filter, m_pOuter->entindex(), "Player.UnProne" );
+
+	// speed up to target speed
+	m_flUnProneTime = gpGlobals->curtime + TIME_TO_PRONE;
+
+	m_flGoProneTime = 0.0f;	//reset 
+}
+
+bool CDODPlayerShared::CanChangePosition( void )
+{
+	if ( IsInMGDeploy() )
+		return false;
+
+	if ( IsGettingUpFromProne() )
+		return false;
+
+	if ( IsGoingProne() )
+		return false;
+
+	return true;
+}
+
+void CDODPlayer::UpdateStepSound( surfacedata_t *psurface, const Vector &vecOrigin, const Vector &vecVelocity )
+{
+	Vector knee;
+	Vector feet;
+	float height;
+	int	fLadder;
+
+	if ( m_flStepSoundTime > 0 )
+	{
+		m_flStepSoundTime -= 1000.0f * gpGlobals->frametime;
+		if ( m_flStepSoundTime < 0 )
+		{
+			m_flStepSoundTime = 0;
+		}
+	}
+
+	if ( m_flStepSoundTime > 0 )
+		return;
+
+	if ( GetFlags() & (FL_FROZEN|FL_ATCONTROLS))
+		return;
+
+	if ( GetMoveType() == MOVETYPE_NOCLIP || GetMoveType() == MOVETYPE_OBSERVER )
+		return;
+
+	if ( !sv_footsteps.GetFloat() )
+		return;
+
+	float speed = VectorLength( vecVelocity );
+	float groundspeed = Vector2DLength( vecVelocity.AsVector2D() );
+
+	// determine if we are on a ladder
+	fLadder = ( GetMoveType() == MOVETYPE_LADDER );
+
+	float flDuck;
+
+	if ( ( GetFlags() & FL_DUCKING) || fLadder )
+	{
+		flDuck = 100;
+	}
+	else
+	{
+		flDuck = 0;
+	}
+
+	static float flMinProneSpeed = 10.0f;
+	static float flMinSpeed = 70.0f;
+	static float flRunSpeed = 110.0f;
+
+	bool onground = ( GetFlags() & FL_ONGROUND );
+	bool movingalongground = ( groundspeed > 0.0f );
+	bool moving_fast_enough =  ( speed >= flMinSpeed );
+
+	// always play a step sound if we are moving faster than 
+
+	// To hear step sounds you must be either on a ladder or moving along the ground AND
+	// You must be moving fast enough
+
+	CheckProneMoveSound( groundspeed, onground );
+
+	if ( !moving_fast_enough || !(fLadder || ( onground && movingalongground )) )
+	{
+		return;
+	}
+
+	bool bWalking = ( speed < flRunSpeed );		// or ducking!
+
+	VectorCopy( vecOrigin, knee );
+	VectorCopy( vecOrigin, feet );
+
+	height = GetPlayerMaxs()[ 2 ] - GetPlayerMins()[ 2 ];
+
+	knee[2] = vecOrigin[2] + 0.2 * height;
+
+	float flVol;
+
+	// find out what we're stepping in or on...
+	if ( fLadder )
+	{
+		psurface = physprops->GetSurfaceData( physprops->GetSurfaceIndex( "ladder" ) );
+		flVol = 1.0;
+		m_flStepSoundTime = 350;
+	}
+	else if ( enginetrace->GetPointContents( knee ) & MASK_WATER )
+	{
+		static int iSkipStep = 0;
+
+		if ( iSkipStep == 0 )
+		{
+			iSkipStep++;
+			return;
+		}
+
+		if ( iSkipStep++ == 3 )
+		{
+			iSkipStep = 0;
+		}
+		psurface = physprops->GetSurfaceData( physprops->GetSurfaceIndex( "wade" ) );
+		flVol = 0.65;
+		m_flStepSoundTime = 600;
+	}
+	else if ( enginetrace->GetPointContents( feet ) & MASK_WATER )
+	{
+		psurface = physprops->GetSurfaceData( physprops->GetSurfaceIndex( "water" ) );
+		flVol = bWalking ? 0.2 : 0.5;
+		m_flStepSoundTime = bWalking ? 400 : 300;		
+	}
+	else
+	{
+		if ( !psurface )
+			return;
+
+		if ( bWalking )
+		{
+			m_flStepSoundTime = 400;
+		}
+		else
+		{
+			if ( speed > 200 )
+			{
+				int speeddiff = PLAYER_SPEED_SPRINT - PLAYER_SPEED_RUN;
+				int diff = speed - PLAYER_SPEED_RUN;
+
+				float percent = (float)diff / (float)speeddiff;
+
+				m_flStepSoundTime = 300.0f - 30.0f * percent;
+			}
+			else 
+			{
+				m_flStepSoundTime = 400;
+			}
+		}
+
+		switch ( psurface->game.material )
+		{
+		default:
+		case CHAR_TEX_CONCRETE:						
+			flVol = bWalking ? 0.2 : 0.5;
+			break;
+
+		case CHAR_TEX_METAL:	
+			flVol = bWalking ? 0.2 : 0.5;
+			break;
+
+		case CHAR_TEX_DIRT:
+			flVol = bWalking ? 0.25 : 0.55;
+			break;
+
+		case CHAR_TEX_VENT:	
+			flVol = bWalking ? 0.4 : 0.7;
+			break;
+
+		case CHAR_TEX_GRATE:
+			flVol = bWalking ? 0.2 : 0.5;
+			break;
+
+		case CHAR_TEX_TILE:	
+			flVol = bWalking ? 0.2 : 0.5;
+			break;
+
+		case CHAR_TEX_SLOSH:
+			flVol = bWalking ? 0.2 : 0.5;
+			break;
+		}
+	}
+
+	m_flStepSoundTime += flDuck; // slower step time if ducking
+
+	if ( GetFlags() & FL_DUCKING )
+	{
+		flVol *= 0.65;
+	}
+
+	// protect us from prediction errors a little bit
+	if ( m_flMinNextStepSoundTime > gpGlobals->curtime )
+	{
+		return;
+	}
+
+	m_flMinNextStepSoundTime = gpGlobals->curtime + 0.1f;	
+
+	PlayStepSound( feet, psurface, flVol, false );
+}
+
+void CDODPlayer::CheckProneMoveSound( int groundspeed, bool onground )
+{
+#ifdef CLIENT_DLL
+	bool bShouldPlay = (groundspeed > 10) && (onground == true) && m_Shared.IsProne() && IsAlive();
+
+	if ( m_bPlayingProneMoveSound && !bShouldPlay )
+	{
+		StopSound( "Player.MoveProne" );
+		m_bPlayingProneMoveSound= false;
+	}
+	else if ( !m_bPlayingProneMoveSound && bShouldPlay )
+	{
+		CRecipientFilter filter;
+		filter.AddRecipientsByPAS( WorldSpaceCenter() );
+		EmitSound( filter, entindex(), "Player.MoveProne" );
+
+		m_bPlayingProneMoveSound = true;
+	}
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : step - 
+//			fvol - 
+//			force - force sound to play
+//-----------------------------------------------------------------------------
+void CDODPlayer::PlayStepSound( Vector &vecOrigin, surfacedata_t *psurface, float fvol, bool force )
+{
+	if ( gpGlobals->maxClients > 1 && !sv_footsteps.GetFloat() )
+		return;
+
+#if defined( CLIENT_DLL )
+	// during prediction play footstep sounds only once
+	if ( prediction->InPrediction() && !prediction->IsFirstTimePredicted() )
+		return;
+#endif
+
+	if ( !psurface )
+		return;
+
+	unsigned short stepSoundName = m_Local.m_nStepside ? psurface->sounds.stepleft : psurface->sounds.stepright;
+	m_Local.m_nStepside = !m_Local.m_nStepside;
+
+	if ( !stepSoundName )
+		return;
+
+	IPhysicsSurfaceProps *physprops = MoveHelper( )->GetSurfaceProps();
+	const char *pSoundName = physprops->GetString( stepSoundName );
+	CSoundParameters params;
+
+	// we don't always know the model, so go by team
+	char *pModelNameForGender = DOD_PLAYERMODEL_AXIS_RIFLEMAN;
+
+	if( GetTeamNumber() == TEAM_ALLIES )
+		pModelNameForGender = DOD_PLAYERMODEL_US_RIFLEMAN;
+
+	if ( !CBaseEntity::GetParametersForSound( pSoundName, params, pModelNameForGender ) )
+		return;	
+
+	CRecipientFilter filter;
+	filter.AddRecipientsByPAS( vecOrigin );
+
+#ifndef CLIENT_DLL
+	// im MP, server removed all players in origins PVS, these players 
+	// generate the footsteps clientside
+	if ( gpGlobals->maxClients > 1 )
+		filter.RemoveRecipientsByPVS( vecOrigin );
+#endif
+
+	EmitSound_t ep;
+	ep.m_nChannel = params.channel;
+	ep.m_pSoundName = params.soundname;
+	ep.m_flVolume = fvol;
+	ep.m_SoundLevel = params.soundlevel;
+	ep.m_nFlags = 0;
+	ep.m_nPitch = params.pitch;
+	ep.m_pOrigin = &vecOrigin;
+
+	EmitSound( filter, entindex(), ep );
+}
+
+Activity CDODPlayer::TranslateActivity( Activity baseAct, bool *pRequired /* = NULL */ )
+{
+	Activity translated = baseAct;
+
+	if ( GetActiveWeapon() )
+	{
+		translated = GetActiveWeapon()->ActivityOverride( baseAct, pRequired );
+	}
+	else if (pRequired)
+	{
+		*pRequired = false;
+	}
+
+	return translated;
+}
+
+void CDODPlayerShared::SetCPIndex( int index )
+{
+#ifdef CLIENT_DLL
+
+	if ( m_pOuter->IsLocalPlayer() )
+	{
+		if ( index == -1 )
+		{
+			// just left an area
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "ObjectiveIconShrink" ); 
+		}
+		else
+		{
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "ObjectiveIconGrow" ); 
+		}
+	}
+
+#endif
+
+	m_iCPIndex = index;
+}
+
+void CDODPlayerShared::SetLastViewAnimTime( float flTime )
+{
+	m_flLastViewAnimationTime = flTime;
+}
+
+float CDODPlayerShared::GetLastViewAnimTime( void )
+{
+	return m_flLastViewAnimationTime;
+}
+
+void CDODPlayerShared::ResetViewOffsetAnimation( void )
+{
+    if ( m_pViewOffsetAnim )
+	{
+		//cancel it!
+		m_pViewOffsetAnim->Reset();
+	}
+}
+
+void CDODPlayerShared::ViewOffsetAnimation( Vector vecDest, float flTime, ViewAnimationType type )
+{
+	if ( !m_pViewOffsetAnim )
+	{
+		m_pViewOffsetAnim =  CViewOffsetAnimation::CreateViewOffsetAnim( m_pOuter );
+	}
+
+	Assert( m_pViewOffsetAnim );
+
+	if ( m_pViewOffsetAnim )
+	{
+		m_pViewOffsetAnim->StartAnimation( m_pOuter->GetViewOffset(), vecDest, flTime, type );
+	}
+}
+
+void CDODPlayerShared::ViewAnimThink( void )
+{
+	// Check for the flag that will reset our view animations
+	// when the player respawns
+	if ( m_bForceProneChange )
+	{
+		ResetViewOffsetAnimation();
+
+		m_pOuter->SetViewOffset( VEC_VIEW_SCALED( m_pOuter ) );
+
+		m_bForceProneChange = false;
+	}
+
+	if ( m_pViewOffsetAnim )
+	{
+		m_pViewOffsetAnim->Think();
+	}
+}
+
+void CDODPlayerShared::ComputeWorldSpaceSurroundingBox( Vector *pVecWorldMins, Vector *pVecWorldMaxs )
+{
+	Vector org = m_pOuter->GetAbsOrigin();
+
+	if ( IsProne() )
+	{
+		static Vector vecProneMin(-44, -44, 0 );
+		static Vector vecProneMax(44, 44, 24 );
+
+		VectorAdd( vecProneMin, org, *pVecWorldMins );
+		VectorAdd( vecProneMax, org, *pVecWorldMaxs );
+	}
+	else
+	{
+		static Vector vecMin(-32, -32, 0 );
+		static Vector vecMax(32, 32, 72 );
+
+		VectorAdd( vecMin, org, *pVecWorldMins );
+		VectorAdd( vecMax, org, *pVecWorldMaxs );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets whether this player is dominating the specified other player
+//-----------------------------------------------------------------------------
+void CDODPlayerShared::SetPlayerDominated( CDODPlayer *pPlayer, bool bDominated )
+{
+	int iPlayerIndex = pPlayer->entindex();
+	m_bPlayerDominated.Set( iPlayerIndex, bDominated );
+	pPlayer->m_Shared.SetPlayerDominatingMe( m_pOuter, bDominated );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets whether this player is being dominated by the other player
+//-----------------------------------------------------------------------------
+void CDODPlayerShared::SetPlayerDominatingMe( CDODPlayer *pPlayer, bool bDominated )
+{
+	int iPlayerIndex = pPlayer->entindex();
+	m_bPlayerDominatingMe.Set( iPlayerIndex, bDominated );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns whether this player is dominating the specified other player
+//-----------------------------------------------------------------------------
+bool CDODPlayerShared::IsPlayerDominated( int iPlayerIndex )
+{
+#ifdef CLIENT_DLL
+	// On the client, we only have data for the local player.
+	// As a result, it's only valid to ask for dominations related to the local player
+	C_DODPlayer *pLocalPlayer = C_DODPlayer::GetLocalDODPlayer();
+	if ( !pLocalPlayer )
+		return false;
+
+	Assert( m_pOuter->IsLocalPlayer() || pLocalPlayer->entindex() == iPlayerIndex );
+
+	if ( m_pOuter->IsLocalPlayer() )
+		return m_bPlayerDominated.Get( iPlayerIndex );
+
+	return pLocalPlayer->m_Shared.IsPlayerDominatingMe( m_pOuter->entindex() );
+#else
+	// Server has all the data.
+	return m_bPlayerDominated.Get( iPlayerIndex );
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CDODPlayerShared::IsPlayerDominatingMe( int iPlayerIndex )
+{
+	return m_bPlayerDominatingMe.Get( iPlayerIndex );
+}