1HEADmaster

1 files changed, 782 insertions, 0 deletions

diff --git a/game/shared/dod/weapon_dodbipodgun.cpp b/game/shared/dod/weapon_dodbipodgun.cpp
new file mode 100644
index 0000000..09b0d40
--- /dev/null
+++ b/game/shared/dod/weapon_dodbipodgun.cpp
@@ -0,0 +1,782 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h" 
+#include "fx_dod_shared.h"
+#include "weapon_dodbipodgun.h"
+#include "dod_gamerules.h"
+#include "engine/IEngineSound.h"
+
+#ifndef CLIENT_DLL
+#include "ndebugoverlay.h"
+#endif
+
+IMPLEMENT_NETWORKCLASS_ALIASED( DODBipodWeapon, DT_BipodWeapon )
+
+BEGIN_NETWORK_TABLE( CDODBipodWeapon, DT_BipodWeapon )
+#ifdef CLIENT_DLL
+	RecvPropBool( RECVINFO( m_bDeployed ) ),
+	RecvPropInt( RECVINFO( m_iDeployedReloadModelIndex) ),
+#else
+	SendPropBool( SENDINFO( m_bDeployed ) ),
+	SendPropModelIndex( SENDINFO(m_iDeployedReloadModelIndex) ),
+#endif
+END_NETWORK_TABLE()
+
+#ifdef CLIENT_DLL
+BEGIN_PREDICTION_DATA( CDODBipodWeapon )
+	DEFINE_PRED_FIELD( m_bDeployed, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE )
+END_PREDICTION_DATA()
+#endif
+
+CDODBipodWeapon::CDODBipodWeapon()
+{
+}
+
+void CDODBipodWeapon::Spawn()
+{
+	SetDeployed( false );
+	m_flNextDeployCheckTime = 0;
+
+	m_iCurrentWorldModel = 0;
+
+	m_iAltFireHint = HINT_USE_DEPLOY;
+
+	BaseClass::Spawn();
+}
+
+void CDODBipodWeapon::SetDeployed( bool bDeployed )
+{
+	if ( bDeployed == false )
+	{
+		m_hDeployedOnEnt = NULL;
+		m_DeployedEntOrigin = vec3_origin;
+		m_flDeployedHeight = 0;
+
+#ifdef GAME_DLL
+		CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+		if ( pPlayer )
+		{
+			pPlayer->HandleDeployedMGKillCount( 0 );	// reset when we undeploy
+		}
+#endif
+	}
+
+	m_bDeployed = bDeployed;
+}
+
+void CDODBipodWeapon::Precache( void )
+{
+	// precache base first, it loads weapon scripts
+	BaseClass::Precache();
+
+	const CDODWeaponInfo &info = GetDODWpnData();
+
+	if( Q_strlen(info.m_szDeployedModel) > 0 )
+	{
+		Assert( info.m_iAltWpnCriteria & ALTWPN_CRITERIA_DEPLOYED );
+		m_iDeployedModelIndex = CBaseEntity::PrecacheModel( info.m_szDeployedModel );
+	}
+
+	if( Q_strlen(info.m_szDeployedReloadModel) > 0 )
+	{
+		Assert( info.m_iAltWpnCriteria & ALTWPN_CRITERIA_DEPLOYED_RELOAD );
+		m_iDeployedReloadModelIndex = CBaseEntity::PrecacheModel( info.m_szDeployedReloadModel );
+	}
+
+	if( Q_strlen(info.m_szProneDeployedReloadModel) > 0 )
+	{
+		Assert( info.m_iAltWpnCriteria & ALTWPN_CRITERIA_PRONE_DEPLOYED_RELOAD );
+		m_iProneDeployedReloadModelIndex = CBaseEntity::PrecacheModel( info.m_szProneDeployedReloadModel );
+	}
+
+	m_iCurrentWorldModel = m_iWorldModelIndex;
+	Assert( m_iCurrentWorldModel != 0 );
+}
+
+bool CDODBipodWeapon::CanDrop( void )
+{
+	return ( IsDeployed() == false );
+}
+
+bool CDODBipodWeapon::CanHolster( void )
+{
+	return ( IsDeployed() == false );
+}
+
+void CDODBipodWeapon::Drop( const Vector &vecVelocity )
+{
+	// If a player is killed while deployed, this resets the weapon state
+	SetDeployed( false );
+
+	BaseClass::Drop( vecVelocity );
+}
+
+void CDODBipodWeapon::SecondaryAttack( void )
+{
+	// Toggle deployed / undeployed
+
+	if ( IsDeployed() )
+		UndeployBipod();
+	else 
+	{
+		if ( CanAttack() )
+		{
+			bool bSuccess = AttemptToDeploy();
+
+			CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+			Assert( pPlayer );
+
+			if ( !bSuccess )
+			{
+				pPlayer->HintMessage( HINT_MG_DEPLOY_USAGE );
+			}
+			else
+			{
+#ifndef CLIENT_DLL
+				pPlayer->RemoveHintTimer( m_iAltFireHint );
+#endif
+			}
+		}
+	}
+}
+
+bool CDODBipodWeapon::Reload( void )
+{
+	bool bSuccess = BaseClass::Reload();
+
+	if ( bSuccess )
+	{
+		m_flNextSecondaryAttack = gpGlobals->curtime;
+	}
+
+	return bSuccess;
+}
+
+#include "in_buttons.h"
+// check in busy frame too, to catch cancelling reloads
+void CDODBipodWeapon::ItemBusyFrame( void )
+{
+	BipodThink();
+
+	CBasePlayer *pPlayer = GetPlayerOwner();
+
+	if ( !pPlayer )
+		return;
+
+	if ((pPlayer->m_nButtons & IN_ATTACK2) && (m_flNextSecondaryAttack <= gpGlobals->curtime))
+	{
+		SecondaryAttack();
+
+		pPlayer->m_nButtons &= ~IN_ATTACK2;
+	}
+
+	BaseClass::ItemBusyFrame();
+}
+
+void CDODBipodWeapon::ItemPostFrame( void )
+{
+	BipodThink();
+	BaseClass::ItemPostFrame();
+}
+
+// see if we're still deployed on the same entity at the same height
+// in future can be expanded to check when deploying on other ents that may move / die / break
+void CDODBipodWeapon::BipodThink( void )
+{
+	if ( m_flNextDeployCheckTime < gpGlobals->curtime )
+	{
+		if ( IsDeployed() )
+		{
+			if ( CheckDeployEnt() == false )
+			{
+				UndeployBipod();
+
+				// cancel any reload in progress
+				m_bInReload = false;
+				m_flNextPrimaryAttack = gpGlobals->curtime + 0.1;
+				m_flNextSecondaryAttack = gpGlobals->curtime + 0.1;
+			}
+		}
+
+		m_flNextDeployCheckTime = gpGlobals->curtime + 0.2;
+	}	
+}
+
+void CDODBipodWeapon::DoFireEffects()
+{
+	BaseClass::DoFireEffects();
+
+	CBaseEntity *pDeployedOn = m_hDeployedOnEnt.Get();
+
+	// in future can be expanded to check when deploying on other ents that may move / die / break
+	if ( pDeployedOn && pDeployedOn->IsPlayer() && IsDeployed() )
+	{
+#ifndef CLIENT_DLL
+		CSingleUserRecipientFilter user( (CBasePlayer *)pDeployedOn );
+		enginesound->SetPlayerDSP( user, 32, false );
+#endif
+	}
+}
+
+// Do the work of deploying the gun at the current location and angles
+void CDODBipodWeapon::DeployBipod( float flHeight, CBaseEntity *pDeployedOn, float flYawLimitLeft, float flYawLimitRight )
+{
+	m_flDeployedHeight = flHeight;
+	m_hDeployedOnEnt = pDeployedOn;
+
+	if ( pDeployedOn )
+        m_DeployedEntOrigin = pDeployedOn->GetAbsOrigin();
+	else
+		m_DeployedEntOrigin = vec3_origin;	// world ent 
+
+	SendWeaponAnim( GetDeployActivity() );
+	SetDeployed( true );
+
+	CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+	pPlayer->m_Shared.SetDeployed( true, flHeight );
+	pPlayer->m_Shared.SetDeployedYawLimits( flYawLimitLeft, flYawLimitRight );
+
+	// Save this off so we do duck checks later, even though we won't be flagged as ducking
+	m_bDuckedWhenDeployed = pPlayer->m_Shared.IsDucking();	
+
+	// More TODO:
+	// recalc our yaw limits if the item we're deployed on has moved or rotated
+	// if our new limits are outside our current eye angles, undeploy us
+
+	m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration();
+	m_flNextSecondaryAttack = gpGlobals->curtime + SequenceDuration();
+	m_flTimeWeaponIdle = gpGlobals->curtime + SequenceDuration();
+}
+
+// Do the work of undeploying the gun
+void CDODBipodWeapon::UndeployBipod( void )
+{
+	SendWeaponAnim( GetUndeployActivity() );
+	SetDeployed( false );
+
+	CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+	pPlayer->m_Shared.SetDeployed( false );
+
+	// if we cancelled our reload by undeploying, don't let the reload complete
+	if ( m_bInReload )
+		m_bInReload = false;
+
+	m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration();
+	m_flNextSecondaryAttack = gpGlobals->curtime + SequenceDuration();
+	pPlayer->m_flNextAttack = m_flNextPrimaryAttack;
+	m_flTimeWeaponIdle = gpGlobals->curtime + SequenceDuration();
+}
+
+#ifndef CLIENT_DLL
+ConVar dod_debugmgdeploy( "dod_debugmgdeploy", "0", FCVAR_CHEAT|FCVAR_GAMEDLL );
+#endif
+
+bool CDODBipodWeapon::AttemptToDeploy( void )
+{
+	CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+
+	if ( pPlayer->GetGroundEntity() == NULL )
+		return false;
+
+	if ( pPlayer->m_Shared.IsGettingUpFromProne() || pPlayer->m_Shared.IsGoingProne() )
+		return false;
+
+	CBaseEntity *pDeployedOn = NULL;
+	float flDeployedHeight = 0.0f;
+	float flYawLimitLeft = 0;
+	float flYawLimitRight = 0;
+
+	if ( TestDeploy( &flDeployedHeight, &pDeployedOn, &flYawLimitLeft, &flYawLimitRight ) )
+	{
+		if ( pPlayer->m_Shared.IsProne() && !pPlayer->m_Shared.IsGettingUpFromProne() )
+		{
+			DeployBipod( flDeployedHeight, NULL, flYawLimitLeft, flYawLimitRight );
+			return true;
+		}
+		else
+		{
+			float flMinDeployHeight = 24.0;
+			if( flDeployedHeight >= flMinDeployHeight )
+			{
+				DeployBipod( flDeployedHeight, pDeployedOn, flYawLimitLeft, flYawLimitRight );
+				return true;
+			}
+		}		
+	}
+
+	return false;
+}
+
+bool CDODBipodWeapon::CheckDeployEnt( void )
+{
+	CBaseEntity *pDeployedOn = NULL;
+	float flDeployedHeight = 0.0f;
+
+	if ( TestDeploy( &flDeployedHeight, &pDeployedOn ) == false )
+		return false;
+
+	// If the entity we were deployed on has changed, or has moved, the origin
+	// of it will be different. If so, recalc our yaw limits.
+	if ( pDeployedOn )
+	{
+		if ( m_DeployedEntOrigin != pDeployedOn->GetAbsOrigin() )
+		{
+			float flYawLimitLeft = 0, flYawLimitRight = 0;
+			TestDeploy( &flDeployedHeight, &pDeployedOn, &flYawLimitLeft, &flYawLimitRight );
+
+			CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+			
+			if ( pPlayer )
+				pPlayer->m_Shared.SetDeployedYawLimits( flYawLimitLeft, flYawLimitRight );
+
+			m_DeployedEntOrigin = pDeployedOn->GetAbsOrigin();
+		}
+	}
+	
+	// 20 unit tolerance in height
+	if ( abs( m_flDeployedHeight - flDeployedHeight ) > 20 )
+		return false;
+
+	return true;
+}
+
+bool CDODBipodWeapon::TestDeploy( float *flDeployedHeight, CBaseEntity **pDeployedOn, float *flYawLimitLeft /* = NULL */, float *flYawLimitRight /* = NULL */ )
+{
+	CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+
+	QAngle angles = pPlayer->EyeAngles();
+
+	float flPitch = angles[PITCH];
+	if( flPitch > 180 )
+	{
+		flPitch -= 360;
+	}
+
+	if( flPitch > MIN_DEPLOY_PITCH || flPitch < MAX_DEPLOY_PITCH )
+	{
+		return false;
+	}
+
+	bool bSuccess = false;
+
+	// if we're not finding the range, test at the current angles
+	if ( flYawLimitLeft == NULL && flYawLimitRight == NULL )
+	{
+		// test our current angle only
+		bSuccess = TestDeployAngle( pPlayer, flDeployedHeight, pDeployedOn, angles );
+	}
+	else
+	{
+		float flSaveYaw = angles[YAW];
+
+		const float flAngleDelta = 5;
+		const float flMaxYaw = 45;
+
+		float flLeft = 0;
+		float flRight = 0;
+
+		float flTestDeployHeight = 0;
+		CBaseEntity *pTestDeployedOn = NULL;
+
+		// Sweep Left
+		while ( flLeft <= flMaxYaw )
+		{
+			angles[YAW] = flSaveYaw + flLeft;
+
+			if ( TestDeployAngle( pPlayer, &flTestDeployHeight, &pTestDeployedOn, angles ) == true )
+			{
+				if ( flLeft == 0 )	// first sweep is authoritative on deploy height and entity
+				{
+					*flDeployedHeight = flTestDeployHeight;
+					*pDeployedOn = pTestDeployedOn;
+				}
+				else if ( abs( *flDeployedHeight - flTestDeployHeight ) > 20 )
+				{
+					// don't allow yaw to a position that is too different in height
+					break;
+				}
+
+				*flYawLimitLeft = flLeft;
+			}
+			else
+			{
+				break;
+			}
+			flLeft += flAngleDelta;
+		}
+
+		// can't deploy here, drop out early
+		if ( flLeft <= 0 )
+			return false;
+
+		// we already tested directly ahead and it was clear. skip one test
+		flRight += flAngleDelta;
+
+		// Sweep Right
+		while ( flRight <= flMaxYaw )
+		{
+			angles[YAW] = flSaveYaw - flRight;
+
+			if ( TestDeployAngle( pPlayer, &flTestDeployHeight, &pTestDeployedOn, angles ) == true )
+			{
+				if ( abs( *flDeployedHeight - flTestDeployHeight ) > 20 )
+				{
+					// don't allow yaw to a position that is too different in height
+					break;
+				}
+
+				*flYawLimitRight = flRight;
+			}
+			else
+			{
+				break;
+			}
+			flRight += flAngleDelta;
+		}
+
+		bSuccess = true;
+	}
+
+	return bSuccess;
+}
+
+//ConVar dod_deploy_box_size( "dod_deploy_box_size", "8", FCVAR_REPLICATED );
+
+#include "util_shared.h"
+
+// trace filter that ignores all players except the passed one
+class CTraceFilterIgnorePlayersExceptFor : public CTraceFilterSimple
+{
+public:
+	// It does have a base, but we'll never network anything below here..
+	DECLARE_CLASS( CTraceFilterIgnorePlayersExceptFor, CTraceFilterSimple );
+
+	CTraceFilterIgnorePlayersExceptFor( const IHandleEntity *passentity, int collisionGroup )
+		: CTraceFilterSimple( passentity, collisionGroup )
+	{
+	}
+
+	virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask )
+	{
+		CBaseEntity *pEntity = EntityFromEntityHandle( pServerEntity );
+
+		if ( pEntity->IsPlayer() )
+		{
+			if ( pEntity != GetPassEntity() )
+			{
+				return false;
+			}
+			else
+				return true;
+		}
+
+		return true;
+	}
+};
+
+#define DEPLOY_DOWNTRACE_FORWARD_DIST	16
+#define DEPLOY_DOWNTRACE_OFFSET	16	// yay for magic numbers
+
+bool CDODBipodWeapon::TestDeployAngle( CDODPlayer *pPlayer, float *flDeployedHeight, CBaseEntity **pDeployedOn, QAngle angles )
+{
+	// make sure we are deployed on the same entity at the same height
+	trace_t tr;	
+
+	angles[PITCH] = 0;
+
+	Vector forward, right, up;
+	AngleVectors( angles, &forward, &right, &up );
+
+	// start at top of player bbox
+	Vector vecStart = pPlayer->GetAbsOrigin();
+
+	float flForwardTraceDist = 32;
+
+	// check us as ducking if we are ducked, or if were ducked when we were deployed
+	bool bDucking = pPlayer->m_Shared.IsDucking() || ( IsDeployed() && m_bDuckedWhenDeployed );
+
+	if ( pPlayer->m_Shared.IsProne() )
+	{
+		vecStart.z += VEC_PRONE_HULL_MAX[2];
+		flForwardTraceDist = 16;
+	}		
+	else if ( bDucking )
+	{
+		vecStart.z += VEC_DUCK_HULL_MAX[2];
+	}
+	else
+	{
+		vecStart.z += 60;
+	}
+
+	int dim = 1;	//	dod_deploy_box_size.GetInt();
+	Vector vecDeployTraceBoxSize( dim, dim, dim );
+
+	vecStart.z -= vecDeployTraceBoxSize[2];
+	vecStart.z -= 4;
+
+	// sandbags are around 50 units high. Shouldn't be able to deploy on anything a lot higher than that
+
+	// optimal standing height ( for animation's sake ) is around 42 units
+	// optimal ducking height is around 20 units ( 20 unit high object, plus 8 units of gun )
+
+	// Start one half box width away from the edge of the player hull
+	Vector vecForwardStart = vecStart + forward * ( VEC_HULL_MAX_SCALED( pPlayer )[0] + vecDeployTraceBoxSize[0] );
+
+	int traceMask = MASK_SOLID;
+
+	CBaseEntity *pDeployedOnPlayer = NULL;
+
+	if ( m_hDeployedOnEnt && m_hDeployedOnEnt->IsPlayer() )
+	{
+		pDeployedOnPlayer = m_hDeployedOnEnt.Get();
+	}
+
+	CTraceFilterIgnorePlayersExceptFor deployedFilter( pDeployedOnPlayer, COLLISION_GROUP_NONE );
+	CTraceFilterSimple undeployedFilter( pPlayer, COLLISION_GROUP_NONE );
+
+	// if we're deployed, skip all players except for the deployed on player
+	// if we're not, only skip ourselves
+	ITraceFilter *filter;
+	if ( IsDeployed() )
+		filter = &deployedFilter;
+	else
+		filter = &undeployedFilter;
+
+	UTIL_TraceHull( vecForwardStart,
+		vecForwardStart + forward * ( flForwardTraceDist - 2 * vecDeployTraceBoxSize[0] ),
+		-vecDeployTraceBoxSize,
+		vecDeployTraceBoxSize,
+		traceMask,	
+		filter,
+		&tr );
+
+#ifndef CLIENT_DLL
+	if ( dod_debugmgdeploy.GetBool() )
+	{
+		NDebugOverlay::Line( vecForwardStart, vecForwardStart + forward * ( flForwardTraceDist - 2 * vecDeployTraceBoxSize[0] ), 0, 0, 255, true, 0.1 );
+		NDebugOverlay::Box( vecForwardStart, -vecDeployTraceBoxSize, vecDeployTraceBoxSize, 255, 0, 0, 128, 0.1 );
+		NDebugOverlay::Box( tr.endpos, -vecDeployTraceBoxSize, vecDeployTraceBoxSize, 0, 0, 255, 128, 0.1 );
+	}
+#endif
+
+	// Test forward, are we trying to deploy into a solid object?
+	if ( tr.fraction < 1.0 )
+	{
+		return false;
+	}
+
+	// If we're prone, we can always deploy, don't do the ground test
+	if ( pPlayer->m_Shared.IsProne() && !pPlayer->m_Shared.IsGettingUpFromProne() )
+	{
+		// MATTTODO: do trace from *front* of player, not from the edge of crouch hull
+		// this is sufficient
+		*flDeployedHeight = PRONE_DEPLOY_HEIGHT;
+		return true;
+	}
+
+	// fix prediction hitch when coming up from prone. client thinks we aren't
+	// prone, but hull is still prone hull
+	// assumes prone hull is shorter than duck hull!
+	if ( pPlayer->WorldAlignMaxs().z <= VEC_PRONE_HULL_MAX.z )
+		return false;
+
+	// Else trace down
+	Vector vecDownTraceStart = vecStart + forward * ( VEC_HULL_MAX_SCALED( pPlayer )[0] + DEPLOY_DOWNTRACE_FORWARD_DIST );
+	int iTraceHeight = -( pPlayer->WorldAlignMaxs().z );
+
+
+	// search down from the forward trace
+	// use the farthest point first. If that fails, move towards the player a few times
+	// to see if they are trying to deploy on a thin railing
+
+	bool bFound = false;
+
+	int maxAttempts = 4;
+	float flHighestTraceEnd = vecDownTraceStart.z + iTraceHeight;
+	CBaseEntity *pBestDeployEnt = NULL;
+
+	while( maxAttempts > 0 )
+	{
+		UTIL_TraceHull( vecDownTraceStart,
+			vecDownTraceStart + Vector(0,0,iTraceHeight),	// trace forward one box width
+			-vecDeployTraceBoxSize,
+			vecDeployTraceBoxSize,
+			traceMask,	
+			filter,
+			&tr );
+
+#ifndef CLIENT_DLL
+		if ( dod_debugmgdeploy.GetBool() )
+		{
+			NDebugOverlay::Line( vecDownTraceStart, tr.endpos, 255, 0, 0, true, 0.1 );
+			NDebugOverlay::Box( vecDownTraceStart, -vecDeployTraceBoxSize, vecDeployTraceBoxSize, 255, 0, 0, 128, 0.1 );
+			NDebugOverlay::Box( tr.endpos, -vecDeployTraceBoxSize, vecDeployTraceBoxSize, 0, 0, 255, 128, 0.1 );
+		}
+#endif
+
+		bool bSuccess = ( tr.fraction < 1.0 ) && !tr.startsolid && !tr.allsolid;
+
+		// if this is the first one found, set found flag
+		if ( bSuccess && !bFound )
+		{
+			bFound = true;
+		}
+		else if ( bFound == true && bSuccess == false )
+		{
+			// it failed and we have some data. break here
+			break;
+		}
+
+		// if this trace is better ( higher ) use this one
+		if ( tr.endpos.z > flHighestTraceEnd )
+		{
+			flHighestTraceEnd = tr.endpos.z;
+			pBestDeployEnt = tr.m_pEnt;
+		}
+
+		--maxAttempts;
+
+		// move towards the player, looking for a better height to deploy on
+		vecDownTraceStart += forward * -4;
+	}
+
+	if ( bFound == false || pBestDeployEnt == NULL )
+		return false;
+
+	*pDeployedOn = pBestDeployEnt;
+	*flDeployedHeight = flHighestTraceEnd - vecDeployTraceBoxSize[0] + DEPLOY_DOWNTRACE_OFFSET - pPlayer->GetAbsOrigin().z;
+	return true;
+}
+
+Activity CDODBipodWeapon::GetUndeployActivity( void )
+{
+	return ACT_VM_UNDEPLOY;
+}
+
+Activity CDODBipodWeapon::GetDeployActivity( void )
+{
+	return ACT_VM_DEPLOY;
+}
+
+
+Activity CDODBipodWeapon::GetPrimaryAttackActivity( void )
+{
+	Activity actPrim;
+
+	if( IsDeployed() )
+		actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED;	
+	else
+		actPrim = ACT_VM_PRIMARYATTACK;
+
+	return actPrim;
+}
+
+Activity CDODBipodWeapon::GetReloadActivity( void )
+{
+	Activity actReload;
+
+	if( IsDeployed() )
+		actReload = ACT_VM_RELOAD_DEPLOYED;	
+	else
+		actReload = ACT_VM_RELOAD;
+
+	return actReload;
+}
+
+Activity CDODBipodWeapon::GetIdleActivity( void )
+{
+	Activity actIdle;
+
+	if( IsDeployed() )
+		actIdle = ACT_VM_IDLE_DEPLOYED;	
+	else
+		actIdle = ACT_VM_IDLE;
+
+	return actIdle;
+}
+
+
+float CDODBipodWeapon::GetWeaponAccuracy( float flPlayerSpeed )
+{
+	float flSpread = BaseClass::GetWeaponAccuracy( flPlayerSpeed );
+	
+	if( IsDeployed() )
+	{
+		flSpread = m_pWeaponInfo->m_flSecondaryAccuracy;
+	}
+
+	return flSpread;
+}
+
+#ifdef CLIENT_DLL
+
+	int CDODBipodWeapon::GetWorldModelIndex( void )
+	{
+		if( GetOwner() == NULL )
+			return m_iWorldModelIndex;
+		else if( m_bUseAltWeaponModel )
+			return m_iWorldModelIndex;	//override for hand signals etc
+		else
+            return m_iCurrentWorldModel;
+	}
+
+	void CDODBipodWeapon::CheckForAltWeapon( int iCurrentState )
+	{
+		int iCriteria = GetDODWpnData().m_iAltWpnCriteria;
+
+		bool bReloading = ( iCurrentState & ALTWPN_CRITERIA_RELOADING );
+
+		if( bReloading )
+		{
+			if( IsDeployed() && iCurrentState & ALTWPN_CRITERIA_PRONE && 
+				iCriteria & ALTWPN_CRITERIA_PRONE_DEPLOYED_RELOAD )
+			{
+				m_iCurrentWorldModel = m_iProneDeployedReloadModelIndex;		// prone deployed reload	
+			}
+			else if( IsDeployed() && iCriteria & ALTWPN_CRITERIA_DEPLOYED_RELOAD )
+			{
+				m_iCurrentWorldModel = m_iDeployedReloadModelIndex;		// deployed reload			
+			}
+			else if( iCriteria & ALTWPN_CRITERIA_RELOADING )
+			{
+				m_iCurrentWorldModel = m_iReloadModelIndex;				// left handed reload			
+			}
+			else 
+			{
+				m_iCurrentWorldModel = m_iWorldModelIndex;				// normal weapon reload
+			}
+		}
+		else if( IsDeployed() && iCriteria & ALTWPN_CRITERIA_DEPLOYED )
+		{
+			m_iCurrentWorldModel = m_iDeployedModelIndex;				// bipod down
+		}
+		else if( (iCurrentState & iCriteria) & ALTWPN_CRITERIA_FIRING )
+		{
+			// don't think we have any weapons that do this
+			m_iCurrentWorldModel = m_iReloadModelIndex;					// left handed shooting?	
+		}
+		else
+		{
+			m_iCurrentWorldModel = m_iWorldModelIndex;					// normal weapon
+		}
+	}
+
+	ConVar deployed_mg_sensitivity( "deployed_mg_sensitivity", "0.9", FCVAR_CHEAT, "Mouse sensitivity while deploying a machine gun" );
+
+	void CDODBipodWeapon::OverrideMouseInput( float *x, float *y )
+	{
+		if( IsDeployed() )
+		{
+			float flSensitivity = deployed_mg_sensitivity.GetFloat();
+
+			*x *= flSensitivity;
+			*y *= flSensitivity;		
+		}
+	}
+
+#endif