1HEADmaster

1 files changed, 1416 insertions, 0 deletions

diff --git a/game/shared/dod/weapon_dodbase.cpp b/game/shared/dod/weapon_dodbase.cpp
new file mode 100644
index 0000000..3c1fc98
--- /dev/null
+++ b/game/shared/dod/weapon_dodbase.cpp
@@ -0,0 +1,1416 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "in_buttons.h"
+#include "takedamageinfo.h"
+#include "weapon_dodbase.h"
+#include "ammodef.h"
+#include "dod_gamerules.h"
+
+#ifdef CLIENT_DLL
+extern IVModelInfoClient* modelinfo;
+#else
+extern IVModelInfo* modelinfo;
+#include "ilagcompensationmanager.h"
+#endif
+
+
+#if defined( CLIENT_DLL )
+
+	#include "vgui/ISurface.h"
+	#include "vgui_controls/Controls.h"
+	#include "c_dod_player.h"
+	#include "hud_crosshair.h"
+	#include "SoundEmitterSystem/isoundemittersystembase.h"
+
+#else
+
+	#include "dod_player.h"
+
+#endif
+
+#include "effect_dispatch_data.h"
+
+
+// ----------------------------------------------------------------------------- //
+// Global functions.
+// ----------------------------------------------------------------------------- //
+
+bool IsAmmoType( int iAmmoType, const char *pAmmoName )
+{
+	return GetAmmoDef()->Index( pAmmoName ) == iAmmoType;
+}
+
+//--------------------------------------------------------------------------------------------------------
+//
+// Given a weapon ID, return its alias
+//
+const char *WeaponIDToAlias( int id )
+{
+	if ( (id >= WEAPON_MAX) || (id < 0) )
+		return NULL;
+
+	return s_WeaponAliasInfo[id];
+}
+
+// ----------------------------------------------------------------------------- //
+// CWeaponDODBase tables.
+// ----------------------------------------------------------------------------- //
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponDODBase, DT_WeaponDODBase )
+
+BEGIN_NETWORK_TABLE( CWeaponDODBase, DT_WeaponDODBase )
+#ifdef CLIENT_DLL
+	RecvPropInt( RECVINFO(m_iReloadModelIndex) ),
+	RecvPropVector( RECVINFO( m_vInitialDropVelocity ) ),
+	RecvPropTime( RECVINFO( m_flSmackTime ) )
+#else
+	SendPropVector( SENDINFO( m_vInitialDropVelocity ), 
+			20,		// nbits
+			0,		// flags
+			-3000,	// low value
+			3000	// high value
+			),
+	SendPropModelIndex( SENDINFO(m_iReloadModelIndex) ),
+	SendPropTime( SENDINFO( m_flSmackTime ) )
+#endif
+END_NETWORK_TABLE()
+
+LINK_ENTITY_TO_CLASS( weapon_dod_base, CWeaponDODBase );
+
+
+#ifdef GAME_DLL
+
+	BEGIN_DATADESC( CWeaponDODBase )
+
+		DEFINE_FUNCTION( FallThink ),
+		DEFINE_FUNCTION( Die ),
+
+		DEFINE_FUNCTION( Smack )
+
+	END_DATADESC()
+
+#else
+	BEGIN_PREDICTION_DATA( CWeaponDODBase ) 
+		DEFINE_PRED_FIELD( m_flSmackTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),	// for rifle melee attacks
+		DEFINE_FIELD( m_bInAttack, FIELD_BOOLEAN )
+	END_PREDICTION_DATA()
+#endif
+
+Vector head_hull_mins( -16, -16, -18 );
+Vector head_hull_maxs( 16, 16, 18 );
+
+void FindHullIntersection( const Vector &vecSrc, trace_t &tr, const Vector &mins, const Vector &maxs, CBaseEntity *pEntity )
+{
+	int			i, j, k;
+	float		distance;
+	Vector minmaxs[2] = {mins, maxs};
+	trace_t tmpTrace;
+	Vector		vecHullEnd = tr.endpos;
+	Vector		vecEnd;
+
+	CTraceFilterSimple filter( pEntity, COLLISION_GROUP_NONE );
+
+	distance = 1e6f;
+
+	vecHullEnd = vecSrc + ((vecHullEnd - vecSrc)*2);
+	UTIL_TraceLine( vecSrc, vecHullEnd, MASK_SOLID, &filter, &tmpTrace );
+	if ( tmpTrace.fraction < 1.0 )
+	{
+		tr = tmpTrace;
+		return;
+	}
+
+	for ( i = 0; i < 2; i++ )
+	{
+		for ( j = 0; j < 2; j++ )
+		{
+			for ( k = 0; k < 2; k++ )
+			{
+				vecEnd.x = vecHullEnd.x + minmaxs[i][0];
+				vecEnd.y = vecHullEnd.y + minmaxs[j][1];
+				vecEnd.z = vecHullEnd.z + minmaxs[k][2];
+
+				UTIL_TraceLine( vecSrc, vecEnd, MASK_SOLID, &filter, &tmpTrace );
+				if ( tmpTrace.fraction < 1.0 )
+				{
+					float thisDistance = (tmpTrace.endpos - vecSrc).Length();
+					if ( thisDistance < distance )
+					{
+						tr = tmpTrace;
+						distance = thisDistance;
+					}
+				}
+			}
+		}
+	}
+}
+
+// ----------------------------------------------------------------------------- //
+// CWeaponDODBase implementation. 
+// ----------------------------------------------------------------------------- //
+CWeaponDODBase::CWeaponDODBase()
+{
+	SetPredictionEligible( true );
+	m_bInAttack = false;
+	m_iAltFireHint = 0;
+	AddSolidFlags( FSOLID_TRIGGER ); // Nothing collides with these but it gets touches.
+
+	m_flNextPrimaryAttack = 0;
+}
+
+
+bool CWeaponDODBase::IsPredicted() const
+{ 
+	return true;
+}
+
+bool CWeaponDODBase::PlayEmptySound()
+{
+	CPASAttenuationFilter filter( this );
+	filter.UsePredictionRules();
+	EmitSound( filter, entindex(), "Default.ClipEmpty_Rifle" );
+
+	return false;
+}
+
+
+CBasePlayer* CWeaponDODBase::GetPlayerOwner() const
+{
+	return dynamic_cast< CBasePlayer* >( GetOwner() );
+}
+
+CDODPlayer* CWeaponDODBase::GetDODPlayerOwner() const
+{
+	return dynamic_cast< CDODPlayer* >( GetOwner() );
+}
+
+bool CWeaponDODBase::SendWeaponAnim( int iActivity )
+{
+	return BaseClass::SendWeaponAnim( iActivity );
+}
+
+bool CWeaponDODBase::CanAttack( void )
+{
+	CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+
+	if ( pPlayer )
+	{
+		return pPlayer->CanAttack();
+	}
+
+	return false;
+}
+
+bool CWeaponDODBase::ShouldAutoReload( void )
+{
+	CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+
+	if ( pPlayer )
+	{
+		return pPlayer->ShouldAutoReload();
+	}
+
+	return false;
+}
+
+void CWeaponDODBase::ItemPostFrame()
+{
+	if ( m_flSmackTime > 0 && gpGlobals->curtime > m_flSmackTime )
+	{
+		Smack();
+		m_flSmackTime = -1;
+	}
+
+	CBasePlayer *pPlayer = GetPlayerOwner();
+
+	if ( !pPlayer )
+		return;
+
+#ifdef _DEBUG
+	CDODGameRules *mp = DODGameRules();
+#endif
+
+	assert( mp );
+
+	if ((m_bInReload) && (pPlayer->m_flNextAttack <= gpGlobals->curtime))
+	{
+		// complete the reload. 
+		int j = MIN( GetMaxClip1() - m_iClip1, pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) );	
+
+		// Add them to the clip
+		m_iClip1 += j;
+		pPlayer->RemoveAmmo( j, m_iPrimaryAmmoType );
+
+		m_bInReload = false;
+
+		FinishReload();
+	}
+
+	if ((pPlayer->m_nButtons & IN_ATTACK2) && (m_flNextSecondaryAttack <= gpGlobals->curtime))
+	{
+		if ( m_iClip2 != -1 && !pPlayer->GetAmmoCount( GetSecondaryAmmoType() ) )
+		{
+			m_bFireOnEmpty = TRUE;
+		}
+
+		SecondaryAttack();
+
+		pPlayer->m_nButtons &= ~IN_ATTACK2;
+	}
+	else if ((pPlayer->m_nButtons & IN_ATTACK) && (m_flNextPrimaryAttack <= gpGlobals->curtime ) && !m_bInAttack )
+	{
+		if ( (m_iClip1 == 0/* && pszAmmo1()*/) || (GetMaxClip1() == -1 && !pPlayer->GetAmmoCount( GetPrimaryAmmoType() ) ) )
+		{
+			m_bFireOnEmpty = TRUE;
+		}
+
+		if( CanAttack() )
+			PrimaryAttack();
+	}
+	else if ( pPlayer->m_nButtons & IN_RELOAD && GetMaxClip1() != WEAPON_NOCLIP && !m_bInReload && m_flNextPrimaryAttack < gpGlobals->curtime) 
+	{
+		// reload when reload is pressed, or if no buttons are down and weapon is empty.		
+		Reload();	
+	}
+	else if ( !(pPlayer->m_nButtons & (IN_ATTACK|IN_ATTACK2) ) )
+	{
+		// no fire buttons down
+
+		m_bFireOnEmpty = false;
+
+		m_bInAttack = false;	//reset semi-auto
+
+		if ( !IsUseable() && m_flNextPrimaryAttack < gpGlobals->curtime ) 
+		{
+			// Intentionally blank -- used to switch weapons here
+		}
+		else if( ShouldAutoReload() )
+		{
+			// weapon is useable. Reload if empty and weapon has waited as long as it has to after firing
+			if ( m_iClip1 == 0 && !(GetWeaponFlags() & ITEM_FLAG_NOAUTORELOAD) && m_flNextPrimaryAttack < gpGlobals->curtime )
+			{
+				Reload();
+				return;
+			}
+		}
+
+		WeaponIdle( );
+		return;
+	}
+}
+
+void CWeaponDODBase::WeaponIdle()
+{
+	if (m_flTimeWeaponIdle > gpGlobals->curtime)
+		return;
+
+	SendWeaponAnim( GetIdleActivity() );
+
+	m_flTimeWeaponIdle = gpGlobals->curtime + SequenceDuration();
+}
+
+Activity CWeaponDODBase::GetIdleActivity( void )
+{
+	return ACT_VM_IDLE;
+}
+
+const CDODWeaponInfo &CWeaponDODBase::GetDODWpnData() const
+{
+	const FileWeaponInfo_t *pWeaponInfo = &GetWpnData();
+	const CDODWeaponInfo *pDODInfo;
+
+	#ifdef _DEBUG
+		pDODInfo = dynamic_cast< const CDODWeaponInfo* >( pWeaponInfo );
+		Assert( pDODInfo );
+	#else
+		pDODInfo = static_cast< const CDODWeaponInfo* >( pWeaponInfo );
+	#endif
+
+	return *pDODInfo;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+const char *CWeaponDODBase::GetViewModel( int /*viewmodelindex = 0 -- this is ignored in the base class here*/ ) const
+{
+	if ( GetPlayerOwner() == NULL )
+	{
+		 return BaseClass::GetViewModel();
+	}
+	
+	return GetWpnData().szViewModel;
+}
+
+void CWeaponDODBase::Precache( void )
+{
+	// precache base first, it loads weapon scripts
+	BaseClass::Precache();
+
+	PrecacheScriptSound( "Default.ClipEmpty_Rifle" );
+
+	PrecacheParticleSystem( "muzzle_pistols" );
+	PrecacheParticleSystem( "muzzle_fullyautomatic" );
+	PrecacheParticleSystem( "muzzle_rifles" );
+	PrecacheParticleSystem( "muzzle_rockets" );
+	PrecacheParticleSystem( "muzzle_mg42" );
+
+	PrecacheParticleSystem( "view_muzzle_pistols" );
+	PrecacheParticleSystem( "view_muzzle_fullyautomatic" );
+	PrecacheParticleSystem( "view_muzzle_rifles" );
+	PrecacheParticleSystem( "view_muzzle_rockets" );
+	PrecacheParticleSystem( "view_muzzle_mg42" );
+
+	const CDODWeaponInfo &info = GetDODWpnData();
+
+	int iWpnNameLen = Q_strlen(info.m_szReloadModel);
+
+#ifdef DEBUG
+	// Make sure that if we declare an alt weapon, that we have criteria to show it
+	// and vice-versa
+	//Assert( ((info.m_iAltWpnCriteria & (ALTWPN_CRITERIA_RELOADING | ALTWPN_CRITERIA_FIRING)) > 0 ) ==
+	//		(iWpnNameLen > 0) );  	
+#endif
+
+	if( iWpnNameLen > 0 )
+		m_iReloadModelIndex = CBaseEntity::PrecacheModel( info.m_szReloadModel );	
+}
+
+bool CWeaponDODBase::DefaultDeploy( char *szViewModel, char *szWeaponModel, int iActivity, char *szAnimExt )
+{
+	CBasePlayer *pOwner = GetPlayerOwner();
+	if ( !pOwner )
+	{
+		return false;
+	}
+
+	pOwner->SetAnimationExtension( szAnimExt );
+
+	SetViewModel();
+	SendWeaponAnim( iActivity );
+
+	pOwner->SetNextAttack( gpGlobals->curtime + SequenceDuration() );
+	m_flNextPrimaryAttack	= MAX( m_flNextPrimaryAttack, gpGlobals->curtime );
+	m_flNextSecondaryAttack	= gpGlobals->curtime;
+
+	SetWeaponVisible( true );
+	SetWeaponModelIndex( szWeaponModel );
+
+	CBaseViewModel *vm = pOwner->GetViewModel( m_nViewModelIndex );
+
+	Assert( vm );
+
+	if( vm )
+	{
+		//set sleeves to proper team
+		switch( pOwner->GetTeamNumber() )
+		{
+		case TEAM_ALLIES:
+			vm->m_nSkin = SLEEVE_ALLIES;
+			break;
+		case TEAM_AXIS:
+			vm->m_nSkin = SLEEVE_AXIS;
+			break;
+		default:
+			Assert( !"TEAM_UNASSIGNED or spectator getting a view model assigned" );
+			break;
+		}
+	}	
+
+	return true;
+}
+
+void CWeaponDODBase::SetWeaponModelIndex( const char *pName )
+{
+ 	 m_iWorldModelIndex = modelinfo->GetModelIndex( pName );
+}
+
+bool CWeaponDODBase::CanBeSelected( void )
+{
+	if ( !VisibleInWeaponSelection() )
+		return false;
+
+	return true;
+}
+
+bool CWeaponDODBase::CanDeploy( void )
+{
+	return BaseClass::CanDeploy();
+}
+
+bool CWeaponDODBase::CanHolster( void )
+{
+	return BaseClass::CanHolster();
+}
+
+void CWeaponDODBase::Drop( const Vector &vecVelocity )
+{
+#ifndef CLIENT_DLL
+	if ( m_iAltFireHint )
+	{
+		CDODPlayer *pPlayer = GetDODPlayerOwner();
+		if ( pPlayer )
+		{
+			pPlayer->StopHintTimer( m_iAltFireHint );
+		}
+	}
+#endif
+
+	// cancel any reload in progress
+	m_bInReload = false;
+
+	m_flSmackTime = -1;
+	
+	m_vInitialDropVelocity = vecVelocity;
+
+	BaseClass::Drop( m_vInitialDropVelocity );
+}
+
+bool CWeaponDODBase::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+#ifndef CLIENT_DLL
+	CDODPlayer *pPlayer = GetDODPlayerOwner();
+
+	if ( pPlayer )
+	{
+		pPlayer->SetFOV( pPlayer, 0 ); // reset the default FOV.
+
+		if ( m_iAltFireHint )
+		{
+			pPlayer->StopHintTimer( m_iAltFireHint );
+		}
+	}
+#endif
+
+	m_bInReload = false;
+
+	m_flSmackTime = -1;
+
+	return BaseClass::Holster( pSwitchingTo );
+}
+
+bool CWeaponDODBase::Deploy()
+{
+#ifndef CLIENT_DLL
+	CDODPlayer *pPlayer = GetDODPlayerOwner();
+
+	if ( pPlayer )
+	{
+		pPlayer->SetFOV( pPlayer, 0 );
+
+		if ( m_iAltFireHint )
+		{
+			pPlayer->StartHintTimer( m_iAltFireHint );
+		}
+	}
+#endif
+
+	return BaseClass::Deploy();
+}
+
+#ifdef CLIENT_DLL
+	
+	void CWeaponDODBase::PostDataUpdate( DataUpdateType_t updateType )
+	{
+		// We need to do this before the C_BaseAnimating code starts to drive
+		// clientside animation sequences on this model, which will be using bad sequences for the world model.
+		int iDesiredModelIndex = 0;
+		C_BasePlayer *localplayer = C_BasePlayer::GetLocalPlayer();
+		if ( localplayer && localplayer == GetOwner() && !C_BasePlayer::ShouldDrawLocalPlayer() )		// FIXME: use localplayer->ShouldDrawThisPlayer() instead.
+		{
+			iDesiredModelIndex = m_iViewModelIndex;
+		}
+		else
+		{
+			iDesiredModelIndex = GetWorldModelIndex();
+
+			// Our world models never animate
+			SetSequence( 0 );
+		}
+
+		if ( GetModelIndex() != iDesiredModelIndex )
+		{
+			SetModelIndex( iDesiredModelIndex );
+		}
+
+		BaseClass::PostDataUpdate( updateType );
+	}
+
+	void CWeaponDODBase::OnDataChanged( DataUpdateType_t type )
+	{
+		if ( m_iState == WEAPON_NOT_CARRIED && m_iOldState != WEAPON_NOT_CARRIED ) 
+		{
+			// we are being notified of the weapon being dropped
+			// add an interpolation history so the movement is smoother
+
+			// Now stick our initial velocity into the interpolation history 
+			CInterpolatedVar< Vector > &interpolator = GetOriginInterpolator();
+
+			interpolator.ClearHistory();
+			float changeTime = GetLastChangeTime( LATCH_SIMULATION_VAR );
+
+			// Add a sample 1 second back.
+			Vector vCurOrigin = GetLocalOrigin() - m_vInitialDropVelocity;
+			interpolator.AddToHead( changeTime - 1.0, &vCurOrigin, false );
+
+			// Add the current sample.
+			vCurOrigin = GetLocalOrigin();
+			interpolator.AddToHead( changeTime, &vCurOrigin, false );
+
+			Vector estVel;
+			EstimateAbsVelocity( estVel );
+
+			/*Msg( "estimated velocity ( %.1f %.1f %.1f )  initial velocity ( %.1f %.1f %.1f )\n",
+				estVel.x,
+				estVel.y,
+				estVel.z,
+				m_vInitialDropVelocity.m_Value.x,
+				m_vInitialDropVelocity.m_Value.y,
+				m_vInitialDropVelocity.m_Value.z );*/
+
+			OnWeaponDropped();
+		}
+
+		BaseClass::OnDataChanged( type );
+
+		if ( GetPredictable() && !ShouldPredict() )
+			ShutdownPredictable();
+	}
+
+	int CWeaponDODBase::GetWorldModelIndex( void )
+	{
+		if( m_bUseAltWeaponModel && GetOwner() != NULL )
+			return m_iReloadModelIndex;
+		else
+            return m_iWorldModelIndex;
+	}
+
+	bool CWeaponDODBase::ShouldPredict()
+	{
+		if ( GetOwner() && GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+
+	void CWeaponDODBase::ProcessMuzzleFlashEvent()
+	{
+		CDODPlayer *pPlayer = GetDODPlayerOwner();
+		if ( pPlayer )
+			pPlayer->ProcessMuzzleFlashEvent();
+
+		BaseClass::ProcessMuzzleFlashEvent();
+	}
+#else
+		
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Get the accuracy derived from weapon and player, and return it
+	//-----------------------------------------------------------------------------
+	const Vector& CWeaponDODBase::GetBulletSpread()
+	{
+		static Vector cone = VECTOR_CONE_8DEGREES;
+		return cone;
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	//-----------------------------------------------------------------------------
+	void CWeaponDODBase::ItemBusyFrame()
+	{
+		if( ShouldAutoReload() && !m_bInReload )
+		{
+			// weapon is useable. Reload if empty and weapon has waited as long as it has to after firing
+			if ( m_iClip1 == 0 && !(GetWeaponFlags() & ITEM_FLAG_NOAUTORELOAD) && m_flNextPrimaryAttack < gpGlobals->curtime )
+			{
+				Reload();
+			}
+		}
+
+		BaseClass::ItemBusyFrame();
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Match the anim speed to the weapon speed while crouching
+	//-----------------------------------------------------------------------------
+	float CWeaponDODBase::GetDefaultAnimSpeed()
+	{
+		return 1.0;
+	}
+
+	bool CWeaponDODBase::ShouldRemoveOnRoundRestart()
+	{
+		if ( GetPlayerOwner() )
+			return false;
+		else
+			return true;
+	}
+
+
+	//=========================================================
+	// Materialize - make a CWeaponDODBase visible and tangible
+	//=========================================================
+	void CWeaponDODBase::Materialize()
+	{
+		if ( IsEffectActive( EF_NODRAW ) )
+		{
+			RemoveEffects( EF_NODRAW );
+			DoMuzzleFlash();
+		}
+
+		AddSolidFlags( FSOLID_TRIGGER );
+
+		SetThink (&CWeaponDODBase::SUB_Remove);
+		SetNextThink( gpGlobals->curtime + 1 );
+	}
+
+	//=========================================================
+	// AttemptToMaterialize - the item is trying to rematerialize,
+	// should it do so now or wait longer?
+	//=========================================================
+	void CWeaponDODBase::AttemptToMaterialize()
+	{
+		float time = g_pGameRules->FlWeaponTryRespawn( this );
+
+		if ( time == 0 )
+		{
+			Materialize();
+			return;
+		}
+
+		SetNextThink( gpGlobals->curtime + time );
+	}
+
+	//=========================================================
+	// CheckRespawn - a player is taking this weapon, should 
+	// it respawn?
+	//=========================================================
+	void CWeaponDODBase::CheckRespawn()
+	{
+		//GOOSEMAN : Do not respawn weapons!
+		return;
+	}
+
+		
+	//=========================================================
+	// Respawn- this item is already in the world, but it is
+	// invisible and intangible. Make it visible and tangible.
+	//=========================================================
+	CBaseEntity* CWeaponDODBase::Respawn()
+	{
+		// make a copy of this weapon that is invisible and inaccessible to players (no touch function). The weapon spawn/respawn code
+		// will decide when to make the weapon visible and touchable.
+		CBaseEntity *pNewWeapon = CBaseEntity::Create( GetClassname(), g_pGameRules->VecWeaponRespawnSpot( this ), GetAbsAngles(), GetOwner() );
+
+		if ( pNewWeapon )
+		{
+			pNewWeapon->AddEffects( EF_NODRAW );// invisible for now
+			pNewWeapon->SetTouch( NULL );// no touch
+			pNewWeapon->SetThink( &CWeaponDODBase::AttemptToMaterialize );
+
+			UTIL_DropToFloor( this, MASK_SOLID );
+
+			// not a typo! We want to know when the weapon the player just picked up should respawn! This new entity we created is the replacement,
+			// but when it should respawn is based on conditions belonging to the weapon that was taken.
+			pNewWeapon->SetNextThink( gpGlobals->curtime + g_pGameRules->FlWeaponRespawnTime( this ) );
+		}
+		else
+		{
+			Msg( "Respawn failed to create %s!\n", GetClassname() );
+		}
+
+		return pNewWeapon;
+	}
+
+	bool CWeaponDODBase::Reload()
+	{
+		return BaseClass::Reload();
+	}
+
+	void CWeaponDODBase::Spawn()
+	{
+		BaseClass::Spawn();
+
+		// Set this here to allow players to shoot dropped weapons
+		SetCollisionGroup( COLLISION_GROUP_WEAPON );
+		
+		SetExtraAmmoCount(0);	//Start with no additional ammo
+
+		CollisionProp()->UseTriggerBounds( true, 10.0f );
+	}
+	
+	void CWeaponDODBase::SetDieThink( bool bDie )
+	{
+		if( bDie )
+			SetContextThink( &CWeaponDODBase::Die, gpGlobals->curtime + 45.0f, "DieContext" );
+		else
+			SetContextThink( NULL, gpGlobals->curtime, "DieContext" );
+	}
+
+	void CWeaponDODBase::Die( void )
+	{
+		UTIL_Remove( this );
+	}
+
+#endif
+
+void CWeaponDODBase::OnPickedUp( CBaseCombatCharacter *pNewOwner )
+{
+	BaseClass::OnPickedUp( pNewOwner );
+
+#if !defined( CLIENT_DLL )
+	SetDieThink( false );
+#endif
+}
+
+bool CWeaponDODBase::DefaultReload( int iClipSize1, int iClipSize2, int iActivity )
+{
+	CBaseCombatCharacter *pOwner = GetOwner();
+	if (!pOwner)
+		return false;
+
+	// If I don't have any spare ammo, I can't reload
+	if ( pOwner->GetAmmoCount(m_iPrimaryAmmoType) <= 0 )
+		return false;
+
+	bool bReload = false;
+
+	// If you don't have clips, then don't try to reload them.
+	if ( UsesClipsForAmmo1() )
+	{
+		// need to reload primary clip?
+		int primary	= min(iClipSize1 - m_iClip1, pOwner->GetAmmoCount(m_iPrimaryAmmoType));
+		if ( primary != 0 )
+		{
+			bReload = true;
+		}
+	}
+
+	if ( UsesClipsForAmmo2() )
+	{
+		// need to reload secondary clip?
+		int secondary = min(iClipSize2 - m_iClip2, pOwner->GetAmmoCount(m_iSecondaryAmmoType));
+		if ( secondary != 0 )
+		{
+			bReload = true;
+		}
+	}
+
+	if ( !bReload )
+		return false;
+
+	CDODPlayer *pPlayer = GetDODPlayerOwner();
+	if ( pPlayer )
+	{
+#ifdef CLIENT_DLL
+		PlayWorldReloadSound( pPlayer );
+#else
+		pPlayer->DoAnimationEvent( PLAYERANIMEVENT_RELOAD );
+#endif
+	}
+
+	SendWeaponAnim( iActivity );
+
+	// Play the player's reload animation
+	if ( pOwner->IsPlayer() )
+	{
+		( ( CBasePlayer * )pOwner)->SetAnimation( PLAYER_RELOAD );
+	}
+
+	float flSequenceEndTime = gpGlobals->curtime + SequenceDuration();
+	pOwner->SetNextAttack( flSequenceEndTime );
+	m_flNextPrimaryAttack = m_flNextSecondaryAttack = flSequenceEndTime;
+
+	m_bInReload = true;
+
+	return true;
+}
+
+#ifdef CLIENT_DLL
+	void CWeaponDODBase::PlayWorldReloadSound( CDODPlayer *pPlayer )
+	{
+		Assert( pPlayer );
+
+		const char *shootsound = GetShootSound( RELOAD );
+		if ( !shootsound || !shootsound[0] )
+			return;
+
+		CSoundParameters params;
+
+		if ( !GetParametersForSound( shootsound, params, NULL ) )
+			return;
+
+		// Play weapon sound from the owner
+		CPASAttenuationFilter filter( pPlayer, params.soundlevel );
+		filter.RemoveRecipient( pPlayer );	// no local player, that is done in the model
+
+		EmitSound( filter, pPlayer->entindex(), shootsound, NULL, 0.0 ); 
+	}
+#endif
+
+bool CWeaponDODBase::IsUseable()
+{
+	CBasePlayer *pPlayer = GetPlayerOwner();
+
+	if ( Clip1() <= 0 )
+	{
+		if ( pPlayer->GetAmmoCount( GetPrimaryAmmoType() ) <= 0 && GetMaxClip1() != -1 )			
+		{
+			// clip is empty (or nonexistant) and the player has no more ammo of this type. 
+			return false;
+		}
+	}
+
+	return true;
+}
+
+#ifndef CLIENT_DLL
+ConVar dod_meleeattackforcescale( "dod_meleeattackforcescale", "8.0", FCVAR_CHEAT | FCVAR_GAMEDLL );
+#endif
+
+void CWeaponDODBase::RifleButt( void )
+{
+	//MeleeAttack( 60, MELEE_DMG_BUTTSTOCK | MELEE_DMG_SECONDARYATTACK, 0.2f, 0.9f );
+}
+
+void CWeaponDODBase::Bayonet( void )
+{
+	//MeleeAttack( 60, MELEE_DMG_BAYONET | MELEE_DMG_SECONDARYATTACK, 0.2f, 0.9f );
+}
+
+void CWeaponDODBase::Punch( void )
+{
+	MeleeAttack( 60, MELEE_DMG_FIST | MELEE_DMG_SECONDARYATTACK, 0.2f, 0.4f );
+}
+
+//--------------------------------------------
+// iDamageAmount - how much damage to give
+// iDamageType - DMG_ bits 
+// flDmgDelay - delay between attack and the giving of damage, usually timed to animation
+// flAttackDelay - time until we can next attack 
+//--------------------------------------------
+CBaseEntity *CWeaponDODBase::MeleeAttack( int iDamageAmount, int iDamageType, float flDmgDelay, float flAttackDelay )
+{
+	if ( !CanAttack() )
+		return NULL;
+
+	CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+
+#if !defined (CLIENT_DLL)
+	// Move other players back to history positions based on local player's lag
+	lagcompensation->StartLagCompensation( pPlayer, pPlayer->GetCurrentCommand() );
+#endif
+
+	Vector vForward, vRight, vUp;
+	AngleVectors( pPlayer->EyeAngles(), &vForward, &vRight, &vUp );
+	Vector vecSrc	= pPlayer->Weapon_ShootPosition();
+	Vector vecEnd	= vecSrc + vForward * 48;
+
+	CTraceFilterSimple filter( pPlayer, COLLISION_GROUP_NONE );
+
+	int iTraceMask = MASK_SOLID | CONTENTS_HITBOX | CONTENTS_DEBRIS;
+
+	trace_t tr;
+	UTIL_TraceLine( vecSrc, vecEnd, iTraceMask, &filter, &tr );
+
+	const float rayExtension = 40.0f;
+	UTIL_ClipTraceToPlayers( vecSrc, vecEnd + vForward * rayExtension, iTraceMask, &filter, &tr );
+
+	// If the exact forward trace did not hit, try a larger swept box 
+	if ( tr.fraction >= 1.0 )
+	{
+		Vector head_hull_mins( -16, -16, -18 );
+		Vector head_hull_maxs( 16, 16, 18 );
+
+		UTIL_TraceHull( vecSrc, vecEnd, head_hull_mins, head_hull_maxs, MASK_SOLID, &filter, &tr );
+		if ( tr.fraction < 1.0 )
+		{
+			// Calculate the point of intersection of the line (or hull) and the object we hit
+			// This is and approximation of the "best" intersection
+			CBaseEntity *pHit = tr.m_pEnt;
+			if ( !pHit || pHit->IsBSPModel() )
+				FindHullIntersection( vecSrc, tr, VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX, pPlayer );
+			vecEnd = tr.endpos;	// This is the point on the actual surface (the hull could have hit space)
+
+			// Make sure it is in front of us
+			Vector vecToEnd = vecEnd - vecSrc;
+			VectorNormalize( vecToEnd );
+
+			// if zero length, always hit
+			if ( vecToEnd.Length() > 0 )
+			{
+				float dot = DotProduct( vForward, vecToEnd );
+
+				// sanity that our hit is within range
+				if ( abs(dot) < 0.95 )
+				{
+					// fake that we actually missed
+					tr.fraction = 1.0;
+				}
+			}			
+		}
+	}
+
+	WeaponSound( MELEE_MISS );
+
+	bool bDidHit = ( tr.fraction < 1.0f );
+
+	if ( bDidHit )	//if the swing hit 
+	{	
+		// delay the decal a bit
+		m_trHit = tr;
+
+		// Store the ent in an EHANDLE, just in case it goes away by the time we get into our think function.
+		m_pTraceHitEnt = tr.m_pEnt; 
+
+		m_iSmackDamage = iDamageAmount;
+		m_iSmackDamageType = iDamageType;
+
+		m_flSmackTime = gpGlobals->curtime + flDmgDelay;
+	}
+
+	SendWeaponAnim( GetMeleeActivity() );
+
+	// player animation
+	pPlayer->DoAnimationEvent( PLAYERANIMEVENT_SECONDARY_ATTACK );
+
+	m_flNextPrimaryAttack = gpGlobals->curtime + flAttackDelay;
+	m_flNextSecondaryAttack = gpGlobals->curtime + flAttackDelay;
+	m_flTimeWeaponIdle = gpGlobals->curtime + SequenceDuration();
+
+#ifndef CLIENT_DLL
+	IGameEvent * event = gameeventmanager->CreateEvent( "dod_stats_weapon_attack" );
+	if ( event )
+	{
+		event->SetInt( "attacker", pPlayer->GetUserID() );
+		event->SetInt( "weapon", GetAltWeaponID() );
+
+		gameeventmanager->FireEvent( event );
+	}
+
+	lagcompensation->FinishLagCompensation( pPlayer );
+#endif	//CLIENT_DLL
+
+	return tr.m_pEnt;
+}
+
+//Think function to delay the impact decal until the animation is finished playing
+void CWeaponDODBase::Smack()
+{
+	Assert( GetPlayerOwner() );
+
+	if ( !GetPlayerOwner() )
+		return;
+
+	CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+
+	if ( !pPlayer )
+		return;
+
+	// Check that we are still facing the victim
+	Vector vForward, vRight, vUp;
+	AngleVectors( pPlayer->EyeAngles(), &vForward, &vRight, &vUp );
+	Vector vecSrc	= pPlayer->Weapon_ShootPosition();
+	Vector vecEnd	= vecSrc + vForward * 48;
+
+	CTraceFilterSimple filter( pPlayer, COLLISION_GROUP_NONE );
+
+	int iTraceMask = MASK_SOLID | CONTENTS_HITBOX | CONTENTS_DEBRIS;
+
+	trace_t tr;
+	UTIL_TraceLine( vecSrc, vecEnd, iTraceMask, &filter, &tr );
+
+	const float rayExtension = 40.0f;
+	UTIL_ClipTraceToPlayers( vecSrc, vecEnd + vForward * rayExtension, iTraceMask, &filter, &tr );
+
+	if ( tr.fraction >= 1.0 )
+	{
+		Vector head_hull_mins( -16, -16, -18 );
+		Vector head_hull_maxs( 16, 16, 18 );
+
+		UTIL_TraceHull( vecSrc, vecEnd, head_hull_mins, head_hull_maxs, MASK_SOLID, &filter, &tr );
+		if ( tr.fraction < 1.0 )
+		{
+			// Calculate the point of intersection of the line (or hull) and the object we hit
+			// This is and approximation of the "best" intersection
+			CBaseEntity *pHit = tr.m_pEnt;
+			if ( !pHit || pHit->IsBSPModel() )
+				FindHullIntersection( vecSrc, tr, VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX, pPlayer );
+			vecEnd = tr.endpos;	// This is the point on the actual surface (the hull could have hit space)
+		}
+	}
+
+	m_trHit = tr;
+
+	if ( !m_trHit.m_pEnt || (m_trHit.surface.flags & SURF_SKY) )
+		return;
+
+	if ( m_trHit.fraction == 1.0 )
+		return;
+
+	CPASAttenuationFilter attenuationFilter( this );
+	attenuationFilter.UsePredictionRules();
+
+	if( m_trHit.m_pEnt->IsPlayer() )
+	{
+		if ( m_iSmackDamageType & MELEE_DMG_STRONGATTACK )
+			WeaponSound( SPECIAL1 );
+		else
+            WeaponSound( MELEE_HIT );
+	}
+	else
+		WeaponSound( MELEE_HIT_WORLD );
+
+	int iDamageType = DMG_CLUB | DMG_NEVERGIB;
+
+#ifndef CLIENT_DLL
+	//if they hit the bounding box, just assume a chest hit
+	if( m_trHit.hitgroup == HITGROUP_GENERIC )
+		m_trHit.hitgroup = HITGROUP_CHEST;
+
+	float flDamage = (float)m_iSmackDamage;
+
+	CTakeDamageInfo info( pPlayer, pPlayer, flDamage, iDamageType );
+
+	if ( m_iSmackDamageType & MELEE_DMG_SECONDARYATTACK )
+		info.SetDamageCustom( MELEE_DMG_SECONDARYATTACK );
+
+	float flScale = (1.0f / flDamage) * dod_meleeattackforcescale.GetFloat();
+
+	Vector vecForceDir = vForward;
+
+	CalculateMeleeDamageForce( &info, vecForceDir, m_trHit.endpos, flScale );
+
+	Assert( m_trHit.m_pEnt != GetPlayerOwner() );
+
+	m_trHit.m_pEnt->DispatchTraceAttack( info, vForward, &m_trHit ); 
+	ApplyMultiDamage();
+#endif
+
+	// We've gotten minidumps where this happened.
+	if ( !GetPlayerOwner() )
+		return;
+
+	CEffectData data;
+	data.m_vOrigin = m_trHit.endpos;
+	data.m_vStart = m_trHit.startpos;
+	data.m_nSurfaceProp = m_trHit.surface.surfaceProps;
+	data.m_nHitBox = m_trHit.hitbox;
+#ifdef CLIENT_DLL
+	data.m_hEntity = m_trHit.m_pEnt->GetRefEHandle();
+#else
+	data.m_nEntIndex = m_trHit.m_pEnt->entindex();
+#endif
+
+	CPASFilter effectfilter( data.m_vOrigin );
+
+#ifndef CLIENT_DLL
+	effectfilter.RemoveRecipient( GetPlayerOwner() );
+#endif
+
+	data.m_vAngles = GetPlayerOwner()->GetAbsAngles();
+	data.m_fFlags = 0x1;	//IMPACT_NODECAL;
+	data.m_nDamageType = iDamageType;
+
+	bool bHitPlayer = m_trHit.m_pEnt && m_trHit.m_pEnt->IsPlayer();
+
+	// don't do any impacts if we hit a teammate and ff is off
+	if ( bHitPlayer && 
+		m_trHit.m_pEnt->GetTeamNumber() == GetPlayerOwner()->GetTeamNumber() && 
+		!friendlyfire.GetBool() )
+		return;
+
+	if ( bHitPlayer )
+	{
+		te->DispatchEffect( effectfilter, 0.0, data.m_vOrigin, "Impact", data );
+	}
+	else if ( m_iSmackDamageType & MELEE_DMG_EDGE )
+	{
+		data.m_nDamageType = DMG_SLASH;
+		te->DispatchEffect( effectfilter, 0.0, data.m_vOrigin, "KnifeSlash", data );
+	}
+}
+
+#if defined( CLIENT_DLL )
+
+	float	g_lateralBob = 0;
+	float	g_verticalBob = 0;
+
+	static ConVar	cl_bobcycle( "cl_bobcycle","0.8" );
+	static ConVar	cl_bob( "cl_bob","0.002" );
+	static ConVar	cl_bobup( "cl_bobup","0.5" );
+
+	// Register these cvars if needed for easy tweaking
+	static ConVar	v_iyaw_cycle( "v_iyaw_cycle", "2"/*, FCVAR_UNREGISTERED*/ );
+	static ConVar	v_iroll_cycle( "v_iroll_cycle", "0.5"/*, FCVAR_UNREGISTERED*/ );
+	static ConVar	v_ipitch_cycle( "v_ipitch_cycle", "1"/*, FCVAR_UNREGISTERED*/ );
+	static ConVar	v_iyaw_level( "v_iyaw_level", "0.3"/*, FCVAR_UNREGISTERED*/ );
+	static ConVar	v_iroll_level( "v_iroll_level", "0.1"/*, FCVAR_UNREGISTERED*/ );
+	static ConVar	v_ipitch_level( "v_ipitch_level", "0.3"/*, FCVAR_UNREGISTERED*/ );
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	// Output : float
+	//-----------------------------------------------------------------------------
+	float CWeaponDODBase::CalcViewmodelBob( void )
+	{
+		static	float bobtime;
+		static	float lastbobtime;
+		static  float lastspeed;
+		float	cycle;
+		
+		CBasePlayer *player = ToBasePlayer( GetOwner() );
+		//Assert( player );
+
+		//NOTENOTE: For now, let this cycle continue when in the air, because it snaps badly without it
+
+		if ( ( !gpGlobals->frametime ) || ( player == NULL ) )
+		{
+			//NOTENOTE: We don't use this return value in our case (need to restructure the calculation function setup!)
+			return 0.0f;// just use old value
+		}
+
+		//Find the speed of the player
+		float speed = player->GetLocalVelocity().Length2D();
+		float flmaxSpeedDelta = MAX( 0, (gpGlobals->curtime - lastbobtime) * 320.0f );
+
+		// don't allow too big speed changes
+		speed = clamp( speed, lastspeed-flmaxSpeedDelta, lastspeed+flmaxSpeedDelta );
+		speed = clamp( speed, -320, 320 );
+
+		lastspeed = speed;
+
+		//FIXME: This maximum speed value must come from the server.
+		//		 MaxSpeed() is not sufficient for dealing with sprinting - jdw
+
+		float bob_offset = RemapVal( speed, 0, 320, 0.0f, 1.0f );
+		
+		bobtime += ( gpGlobals->curtime - lastbobtime ) * bob_offset;
+		lastbobtime = gpGlobals->curtime;
+
+		//Calculate the vertical bob
+		cycle = bobtime - (int)(bobtime/cl_bobcycle.GetFloat())*cl_bobcycle.GetFloat();
+		cycle /= cl_bobcycle.GetFloat();
+
+		if ( cycle < cl_bobup.GetFloat() )
+		{
+			cycle = M_PI * cycle / cl_bobup.GetFloat();
+		}
+		else
+		{
+			cycle = M_PI + M_PI*(cycle-cl_bobup.GetFloat())/(1.0 - cl_bobup.GetFloat());
+		}
+		
+		g_verticalBob = speed*0.005f;
+		g_verticalBob = g_verticalBob*0.3 + g_verticalBob*0.7*sin(cycle);
+
+		g_verticalBob = clamp( g_verticalBob, -7.0f, 4.0f );
+
+		//Calculate the lateral bob
+		cycle = bobtime - (int)(bobtime/cl_bobcycle.GetFloat()*2)*cl_bobcycle.GetFloat()*2;
+		cycle /= cl_bobcycle.GetFloat()*2;
+
+		if ( cycle < cl_bobup.GetFloat() )
+		{
+			cycle = M_PI * cycle / cl_bobup.GetFloat();
+		}
+		else
+		{
+			cycle = M_PI + M_PI*(cycle-cl_bobup.GetFloat())/(1.0 - cl_bobup.GetFloat());
+		}
+
+		g_lateralBob = speed*0.005f;
+		g_lateralBob = g_lateralBob*0.3 + g_lateralBob*0.7*sin(cycle);
+		g_lateralBob = clamp( g_lateralBob, -7.0f, 4.0f );
+		
+		//NOTENOTE: We don't use this return value in our case (need to restructure the calculation function setup!)
+		return 0.0f;
+
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	// Input  : &origin - 
+	//			&angles - 
+	//			viewmodelindex - 
+	//-----------------------------------------------------------------------------
+	void CWeaponDODBase::AddViewmodelBob( CBaseViewModel *viewmodel, Vector &origin, QAngle &angles )
+	{
+		Vector	forward, right;
+		AngleVectors( angles, &forward, &right, NULL );
+
+		CalcViewmodelBob();
+
+		// Apply bob, but scaled down to 40%
+		VectorMA( origin, g_verticalBob * 0.4f, forward, origin );
+		
+		// Z bob a bit more
+		origin[2] += g_verticalBob * 0.1f;
+		
+		// bob the angles
+		angles[ ROLL ]	+= g_verticalBob * 0.5f;
+		angles[ PITCH ]	-= g_verticalBob * 0.4f;
+
+		angles[ YAW ]	-= g_lateralBob  * 0.3f;
+
+	//	VectorMA( origin, g_lateralBob * 0.2f, right, origin );
+	}
+	
+	#include "c_te_effect_dispatch.h"
+
+	#define NUM_MUZZLE_FLASH_TYPES 4
+
+	bool CWeaponDODBase::OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options )
+	{
+		if( event == 5001 )
+		{
+			if ( ShouldDrawMuzzleFlash() )
+			{
+				Assert( GetOwnerEntity() == C_BasePlayer::GetLocalPlayer() );
+
+				const char *pszMuzzleFlashEffect;
+
+				switch( GetDODWpnData().m_iMuzzleFlashType )
+				{
+				case DOD_MUZZLEFLASH_PISTOL:
+					pszMuzzleFlashEffect = "view_muzzle_pistols";
+					break;
+				case DOD_MUZZLEFLASH_AUTO:
+					pszMuzzleFlashEffect = "view_muzzle_fullyautomatic";
+					break;
+				case DOD_MUZZLEFLASH_RIFLE:
+					pszMuzzleFlashEffect = "view_muzzle_rifles";
+					break;
+				case DOD_MUZZLEFLASH_MG:
+					pszMuzzleFlashEffect = "view_muzzle_miniguns";
+					break;
+				case DOD_MUZZLEFLASH_ROCKET:
+					pszMuzzleFlashEffect = "view_muzzle_rockets";
+					break;
+				case DOD_MUZZLEFLASH_MG42:
+					pszMuzzleFlashEffect = "view_muzzle_mg42";
+					break;
+				default:
+					pszMuzzleFlashEffect = NULL;
+					break;
+				}
+
+				if ( pszMuzzleFlashEffect )
+				{
+					pViewModel->ParticleProp()->Create( pszMuzzleFlashEffect, PATTACH_POINT_FOLLOW, 1 );
+				}				
+			}
+			return true;
+		}
+		else if( event == 6002 )
+		{
+			CEffectData data;
+			data.m_nHitBox = atoi( options );
+			data.m_hEntity = GetPlayerOwner() ? GetPlayerOwner()->GetRefEHandle() : INVALID_EHANDLE_INDEX;
+			pViewModel->GetAttachment( 2, data.m_vOrigin, data.m_vAngles );
+
+			DispatchEffect( "DOD_EjectBrass", data );
+			return true;
+		}
+
+		return BaseClass::OnFireEvent( pViewModel, origin, angles, event, options );
+	}
+
+	bool CWeaponDODBase::ShouldAutoEjectBrass( void )
+	{
+		// Don't eject brass if further than N units from the local player
+		C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
+		if ( !pLocalPlayer )
+			return true;
+
+		float flMaxDistSqr = 250;
+		flMaxDistSqr *= flMaxDistSqr;
+
+		float flDistSqr = pLocalPlayer->EyePosition().DistToSqr( GetAbsOrigin() );
+		return ( flDistSqr < flMaxDistSqr );
+	}
+
+	bool CWeaponDODBase::GetEjectBrassShellType( void )
+	{
+		return 1;
+	}
+
+	void CWeaponDODBase::SetUseAltModel( bool bUseAltModel )
+	{
+		m_bUseAltWeaponModel = bUseAltModel;
+	}
+
+	void CWeaponDODBase::CheckForAltWeapon( int iCurrentState )
+	{
+		int iCriteria = GetDODWpnData().m_iAltWpnCriteria;
+
+		bool bUseAltModel = false;
+
+		if( ( iCriteria & iCurrentState ) != 0 )
+			bUseAltModel = true;
+
+		SetUseAltModel( bUseAltModel );
+	}
+
+	Vector CWeaponDODBase::GetDesiredViewModelOffset( C_DODPlayer *pOwner )
+	{
+		Vector viewOffset = pOwner->GetViewOffset();
+
+		float flPercent = ( viewOffset.z - VEC_PRONE_VIEW_SCALED( pOwner ).z ) / ( VEC_VIEW_SCALED( pOwner ).z - VEC_PRONE_VIEW_SCALED( pOwner ).z );
+
+		return ( flPercent * GetDODWpnData().m_vecViewNormalOffset +
+			( 1.0 - flPercent ) * GetDODWpnData().m_vecViewProneOffset );
+	}
+
+	bool CWeaponDODBase::ShouldDraw( void )
+	{
+		if ( GetModel() == NULL )
+		{
+			// XXX(johns): Removed, doesn't seem to be the proper spot for this warning given that weapons can call
+			//             ShouldDraw before their properties are filled.
+
+			// C_DODPlayer *pPlayer = C_DODPlayer::GetLocalDODPlayer();
+
+			// Warning( "BADNESS! Tell Matt that the weapon '%s' tried to draw with a null model ( %d, %d, %s ) \n",
+			// 	GetDODWpnData().szClassName,
+			// 	m_iWorldModelIndex.Get(), m_iReloadModelIndex.Get(), m_bUseAltWeaponModel ? "alt" : "not alt" );
+
+			return false;
+		}
+
+		return BaseClass::ShouldDraw();
+	}
+
+#else
+
+	void CWeaponDODBase::AddViewmodelBob( CBaseViewModel *viewmodel, Vector &origin, QAngle &angles )
+	{
+
+	}
+
+	float CWeaponDODBase::CalcViewmodelBob( void )
+	{
+		return 0.0f;
+	}
+
+	void CWeaponDODBase::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
+	{
+		if ( CanDrop() == false )
+			return;
+
+		CDODPlayer *pPlayer = ToDODPlayer( pActivator );
+
+		if ( pPlayer )
+		{
+			pPlayer->PickUpWeapon( this );
+		}         
+	}
+
+#endif
+