1

game/shared/dod/achievements_dod.cpp

@@ -0,0 +1,905 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#include "cbase.h"
+
+#ifdef CLIENT_DLL
+
+#include "achievementmgr.h"
+#include "baseachievement.h"
+#include "c_dod_player.h"
+#include "dod_shareddefs.h"
+#include "c_dod_objective_resource.h"
+#include "dod_gamerules.h"
+
+CAchievementMgr g_AchievementMgrDOD;	// global achievement mgr for DOD
+
+//-----------------------------------------------------------------------------
+// Purpose: Query if the gamerules allows achievement progress at this time
+//-----------------------------------------------------------------------------
+bool GameRulesAllowsAchievements( void )
+{
+	return ( DODGameRules()->State_Get() == STATE_RND_RUNNING );
+}
+
+class CAchievementDODThrowBackGren : public CBaseAchievement
+{
+	void Init() 
+	{
+		// listen for player kill enemy events, base class will increment count each time that happens
+		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		if ( !GameRulesAllowsAchievements() )
+			return;
+
+		C_DODPlayer *pLocalPlayer = C_DODPlayer::GetLocalDODPlayer();
+
+		if ( pAttacker == pLocalPlayer && pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() )
+		{
+			// if we are allies and killed with a german grenade
+			// or if we are axis and killed with a us grenade
+
+			const char *killedwith = event->GetString( "weapon" );
+			int iLocalTeam = pLocalPlayer->GetTeamNumber();
+
+			if ( ( iLocalTeam == TEAM_ALLIES &&	( FStrEq( killedwith, "frag_ger" ) || FStrEq( killedwith, "riflegren_ger" ) ) ) || 
+				 ( iLocalTeam == TEAM_AXIS && ( FStrEq( killedwith, "frag_us" ) || FStrEq( killedwith, "riflegren_us" ) ) ) )
+			{
+				// This kill was made with an enemy grenade.
+				IncrementCount();
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementDODThrowBackGren, ACHIEVEMENT_DOD_THROW_BACK_GREN, "DOD_THROW_BACK_GREN", 1 );
+
+
+class CAchievementDODConsecutiveHeadshots : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+
+		// Handled on server
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementDODConsecutiveHeadshots, ACHIEVEMENT_DOD_CONSECUTIVE_HEADSHOTS, "DOD_CONSECUTIVE_HEADSHOTS", 1 );
+
+
+class CAchievementDODMGPositionStreak : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+
+		// Handled on server
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementDODMGPositionStreak, ACHIEVEMENT_DOD_MG_POSITION_STREAK, "DOD_MG_POSITION_STREAK", 1 );
+
+
+class CAchievementDODWinKnifeFight : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		if ( !GameRulesAllowsAchievements() )
+			return;
+
+		C_DODPlayer *pLocalPlayer = C_DODPlayer::GetLocalDODPlayer();
+
+		if ( pAttacker == pLocalPlayer && pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() )
+		{
+			const char *killedwith = event->GetString( "weapon" );
+
+			if ( FStrEq( killedwith, "amerknife" ) || FStrEq( killedwith, "spade" ) )
+			{
+				C_DODPlayer *pDodVictim = ToDODPlayer( pVictim );
+
+				if ( pDodVictim )
+				{
+					CWeaponDODBase *pWpn = pDodVictim->GetActiveDODWeapon();
+
+					if ( pWpn && pWpn->GetDODWpnData().m_WeaponType == WPN_TYPE_MELEE )
+					{
+						// Kill was made with a melee weapon, killer had melee weapon out
+						IncrementCount();
+					}
+				}
+			}			
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementDODWinKnifeFight, ACHIEVEMENT_DOD_WIN_KNIFE_FIGHT, "DOD_WIN_KNIFE_FIGHT", 1 );
+
+const char *pszOfficialMaps[] =
+{
+	"dod_anzio",
+	"dod_avalanche",
+	"dod_argentan",
+	"dod_colmar",
+	"dod_donner",
+	"dod_flash",
+	"dod_jagd",
+	"dod_kalt",
+	"dod_palermo"
+};
+
+
+class CAchievementDODCustomMaps : public CBaseAchievement
+{
+	// Requires a player to kill at least one player on 5 different non-official maps
+
+	void Init() 
+	{
+		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
+		SetGoal( 5 );
+		SetStoreProgressInSteam( true );
+
+		m_bCheckedCurrentMap = false;
+	}
+
+	virtual void ListenForEvents()
+	{
+		// hax, this is called from LevelInitPreEntity, init per-level here
+		m_bCheckedCurrentMap = false;
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		if ( m_bCheckedCurrentMap ) 
+			return;
+
+		// don't store the map name if we're not going to give achievement progress
+		if ( m_pAchievementMgr->WereCheatsEverOn() )
+			return;
+
+		C_DODPlayer *pLocalPlayer = C_DODPlayer::GetLocalDODPlayer();
+
+		if ( pAttacker == pLocalPlayer && pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() )
+		{
+			char szMap[MAX_PATH];
+			Q_FileBase( engine->GetLevelName(), szMap, ARRAYSIZE( szMap ) );
+
+			if ( !IsOfficialMap( szMap ) && !HasPlayedThisCustomMap() )
+			{
+				IncrementCount();
+
+				UTIL_IncrementMapKey( "killed_a_player" );
+			}
+
+			// stop listening
+			m_bCheckedCurrentMap = true;
+		}
+	}
+
+	bool HasPlayedThisCustomMap( void )
+	{
+		return ( UTIL_GetMapKeyCount( "killed_a_player" ) > 0 );
+	}
+
+	bool IsOfficialMap( const char *pszMapName )
+	{
+		bool bFound = false;
+	
+		for ( int i=0;i<ARRAYSIZE(pszOfficialMaps);i++ )
+		{
+			if ( FStrEq( pszMapName, pszOfficialMaps[i] ) )
+			{
+				bFound = true;
+				break;
+			}
+		}	
+
+		return bFound;
+	}
+
+	bool m_bCheckedCurrentMap;
+
+};
+DECLARE_ACHIEVEMENT( CAchievementDODCustomMaps, ACHIEVEMENT_DOD_PLAY_CUSTOM_MAPS, "DOD_PLAY_CUSTOM_MAPS", 1 );
+
+
+class CAchievementDODKillsWithGrenade : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+
+	virtual void ListenForEvents()
+	{
+		// hax, this is called from LevelInitPreEntity, init per-level here
+		m_flLastKillTime = 0;
+		m_iKillCount = 0;
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		if ( !GameRulesAllowsAchievements() )
+			return;
+
+		C_DODPlayer *pLocalPlayer = C_DODPlayer::GetLocalDODPlayer();
+
+		if ( pAttacker == pLocalPlayer )
+		{
+			// reject non-grenade/non-rocket inflictors
+			const char *killedwith = event->GetString( "weapon" );
+
+			if ( Q_strncmp( killedwith, "frag_", 5 ) &&
+				 Q_strncmp( killedwith, "riflegren_", 10 ) &&
+				 !FStrEq( killedwith, "pschreck" ) &&
+				 !FStrEq( killedwith, "bazooka" ) )
+			{
+				m_flLastKillTime = 0;
+				return;
+			}
+
+			if ( ( gpGlobals->curtime - m_flLastKillTime ) > 0.25 )
+			{
+				m_iKillCount = 0;
+			}
+
+			m_iKillCount++;
+			m_flLastKillTime = gpGlobals->curtime;
+
+			if ( m_iKillCount == 4 )
+			{
+				IncrementCount();
+			}
+		}
+	}
+
+private:
+	float m_flLastKillTime;
+	int m_iKillCount;
+};
+DECLARE_ACHIEVEMENT( CAchievementDODKillsWithGrenade, ACHIEVEMENT_DOD_KILLS_WITH_GRENADE, "DOD_KILLS_WITH_GRENADE", 1 );
+
+
+class CAchievementDODLongRangeRocket : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+
+		// Handled on server
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementDODLongRangeRocket, ACHIEVEMENT_DOD_LONG_RANGE_ROCKET, "DOD_LONG_RANGE_ROCKET", 1 );
+
+
+class CAchievementDODEndRoundKills : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+
+		m_iKillCount = 0;
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "player_spawn" );
+	}
+
+	// Reset the count when we spawn
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( m_iKillCount > 0 &&  0 == Q_strcmp( event->GetName(), "player_spawn" ) && C_BasePlayer::GetLocalPlayer() )
+		{
+			int iUserID = event->GetInt("userid");
+
+			if ( iUserID == C_BasePlayer::GetLocalPlayer()->GetUserID() )
+			{
+				m_iKillCount = 0;
+			}
+		}
+	}
+
+	// count kills in endround. No requirement that your team must have won the round - grenades count
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		DODRoundState state = DODGameRules()->State_Get();
+
+		if ( state == STATE_ALLIES_WIN || state == STATE_AXIS_WIN )
+		{
+			Assert( pAttacker == C_BasePlayer::GetLocalPlayer() );
+
+			if ( pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() )
+			{
+				m_iKillCount++;
+
+				if ( m_iKillCount > 3 )
+				{
+					IncrementCount();
+				}
+			}
+		}
+	}
+
+	int m_iKillCount;
+};
+DECLARE_ACHIEVEMENT( CAchievementDODEndRoundKills, ACHIEVEMENT_DOD_END_ROUND_KILLS, "DOD_END_ROUND_KILLS", 1 );
+
+
+class CAchievementDODCapLastFlag : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+
+		// handled on server
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementDODCapLastFlag, ACHIEVEMENT_DOD_CAP_LAST_FLAG, "DOD_CAP_LAST_FLAG", 1 );
+
+
+class CAchievementDODUseEnemyWeapons : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+
+	// Handled on server
+};
+DECLARE_ACHIEVEMENT( CAchievementDODUseEnemyWeapons, ACHIEVEMENT_DOD_USE_ENEMY_WEAPONS, "DOD_USE_ENEMY_WEAPONS", 1 );
+
+
+class CAchievementDODKillDominatingMG : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+
+		// Handled on server
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementDODKillDominatingMG, ACHIEVEMENT_DOD_KILL_DOMINATING_MG, "DOD_KILL_DOMINATING_MG", 1 );
+
+
+class CAchievementDODColmarDefense : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+
+		// Handled on server
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementDODColmarDefense, ACHIEVEMENT_DOD_COLMAR_DEFENSE, "DOD_COLMAR_DEFENSE", 1 );
+
+
+class CAchievementDODJagdOvertimeCap : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+
+		// Handled on server
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementDODJagdOvertimeCap, ACHIEVEMENT_DOD_JAGD_OVERTIME_CAP, "DOD_JAGD_OVERTIME_CAP", 1 );
+
+
+class CAchievementDODWeaponMastery : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+
+		// Handled on server
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementDODWeaponMastery, ACHIEVEMENT_DOD_WEAPON_MASTERY, "DOD_WEAPON_MASTERY", 1 );
+
+
+class CAchievementDODBlockCaptures : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "dod_capture_blocked" );
+	}
+
+	// New achievement rule - block a capture that would have lost the game for your team
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( !GameRulesAllowsAchievements() )
+			return;
+
+		Assert( FStrEq( event->GetName(), "dod_capture_blocked" ) );
+
+		// was a blocked defuse or plant, don't count
+		if ( event->GetBool("bomb") )
+			return;
+
+		if ( !g_pObjectiveResource )
+			return;
+
+		C_DODPlayer *pPlayer = C_DODPlayer::GetLocalDODPlayer();
+
+		if ( pPlayer && pPlayer->entindex() == event->GetInt("blocker") )
+		{
+			int iCP = event->GetInt( "cp" );
+
+			bool bIsLastOwnedPoint = true;
+
+			int iPlayerTeam = pPlayer->GetTeamNumber();
+
+			for( int i=0;i<g_pObjectiveResource->GetNumControlPoints();i++ )
+			{
+				// assume we own the one we blocked
+				if ( i == iCP )
+					continue;
+
+				// if we find any other points owned by us that aren't hidden, this wasn't the last point
+
+				if( !g_pObjectiveResource->IsCPVisible(i) )
+					continue;
+
+				if ( g_pObjectiveResource->GetOwningTeam(i) == iPlayerTeam )
+				{
+					bIsLastOwnedPoint = false;
+					break;
+				}
+			}
+
+			if ( bIsLastOwnedPoint )
+			{
+				IncrementCount();
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementDODBlockCaptures, ACHIEVEMENT_DOD_BLOCK_CAPTURES, "DOD_BLOCK_CAPTURES", 1 );
+
+
+// achievements part deux
+
+// kills as allies
+// kills as axis
+class CBaseAchievementKillsOnTeam : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
+		SetGoal( 5000 );
+		SetStoreProgressInSteam( true );
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		Assert( pAttacker == C_BasePlayer::GetLocalPlayer() );
+
+		if ( pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() )
+		{
+			if ( pAttacker->GetTeamNumber() == GetTeam() )
+			{
+				IncrementCount();
+			}
+		}
+	}
+
+	virtual int GetTeam( void ) = 0;
+};
+
+class CAchievementKillsAsAllies : public CBaseAchievementKillsOnTeam
+{
+	virtual int GetTeam( void ) { return TEAM_ALLIES; }
+};
+DECLARE_ACHIEVEMENT( CAchievementKillsAsAllies, ACHIEVEMENT_DOD_KILLS_AS_ALLIES, "DOD_KILLS_AS_ALLIES", 1 );
+
+class CAchievementKillsAsAxis : public CBaseAchievementKillsOnTeam
+{
+	virtual int GetTeam( void ) { return TEAM_AXIS; }
+};
+DECLARE_ACHIEVEMENT( CAchievementKillsAsAxis, ACHIEVEMENT_DOD_KILLS_AS_AXIS, "DOD_KILLS_AS_AXIS", 1 );
+
+// rifleman
+// assault
+// support
+// sniper
+// mg
+// bazooka
+class CBaseAchievementKillsAsClass : public CBaseAchievement
+{
+	void Init()
+	{
+		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
+		SetGoal( 1000 );
+		SetStoreProgressInSteam( true );
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		Assert( pAttacker == C_BasePlayer::GetLocalPlayer() );
+
+		if ( pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() )
+		{
+			C_DODPlayer *pDODAttacker = ToDODPlayer( pAttacker );
+
+			if ( pDODAttacker->m_Shared.PlayerClass() == GetClass() )
+			{
+				IncrementCount();
+			}
+		}
+	}
+
+	virtual int GetClass( void ) = 0;
+};
+
+#define DECLARE_KILLS_AS_CLASS_ACHIEVEMENT( classIndex, achievementID ) \
+class CAchievement_##achievementID : public CBaseAchievementKillsAsClass	\
+{	\
+	virtual int GetClass( void ) { return classIndex; }	\
+};	\
+DECLARE_ACHIEVEMENT( CAchievement_##achievementID, ACHIEVEMENT_##achievementID, #achievementID, 1 ) \
+
+DECLARE_KILLS_AS_CLASS_ACHIEVEMENT( 0, DOD_KILLS_AS_RIFLEMAN );
+DECLARE_KILLS_AS_CLASS_ACHIEVEMENT( 1, DOD_KILLS_AS_ASSAULT );
+DECLARE_KILLS_AS_CLASS_ACHIEVEMENT( 2, DOD_KILLS_AS_SUPPORT );
+DECLARE_KILLS_AS_CLASS_ACHIEVEMENT( 3, DOD_KILLS_AS_SNIPER );
+DECLARE_KILLS_AS_CLASS_ACHIEVEMENT( 4, DOD_KILLS_AS_MG );
+DECLARE_KILLS_AS_CLASS_ACHIEVEMENT( 5, DOD_KILLS_AS_BAZOOKAGUY );
+
+// per weapon
+class CBaseAchievementKillsWithWeapon : public CBaseAchievement
+{
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
+	{
+		Assert( pAttacker == C_BasePlayer::GetLocalPlayer() );
+
+		if ( pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() && event != NULL )
+		{
+			if ( FStrEq( event->GetString( "weapon", "" ), GetWeaponName() ) )
+			{
+				IncrementCount();
+			}
+		}
+	}
+
+	virtual const char *GetWeaponName( void ) = 0;
+};
+
+#define DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( weaponName, goalKills, achievementID ) \
+class CAchievement_##achievementID : public CBaseAchievementKillsWithWeapon	\
+{	\
+	void Init()		\
+	{	\
+		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );	\
+		SetGoal( goalKills );	\
+		SetStoreProgressInSteam( true );	\
+	}	\
+	\
+	virtual const char *GetWeaponName( void ) { return weaponName; } \
+};	\
+DECLARE_ACHIEVEMENT( CAchievement_##achievementID, ACHIEVEMENT_##achievementID, #achievementID, 1 ) \
+
+DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "garand", 500, DOD_KILLS_WITH_GARAND );
+DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "thompson", 500, DOD_KILLS_WITH_THOMPSON );
+DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "bar", 500, DOD_KILLS_WITH_BAR );
+DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "spring", 500, DOD_KILLS_WITH_SPRING );
+DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "30cal", 500, DOD_KILLS_WITH_30CAL );
+DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "bazooka", 500, DOD_KILLS_WITH_BAZOOKA );
+
+DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "k98", 500, DOD_KILLS_WITH_K98 );
+DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "mp40", 500, DOD_KILLS_WITH_MP40 );
+DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "mp44", 500, DOD_KILLS_WITH_MP44 );
+DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "k98_scoped", 500, DOD_KILLS_WITH_K98SCOPED );
+DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "mg42", 500, DOD_KILLS_WITH_MG42 );
+DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "pschreck", 500, DOD_KILLS_WITH_PSCHRECK );
+
+DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "colt", 150, DOD_KILLS_WITH_COLT );
+DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "p38", 150, DOD_KILLS_WITH_P38 );
+DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "c96", 150, DOD_KILLS_WITH_C96 );
+DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "m1carbine", 150, DOD_KILLS_WITH_M1CARBINE );
+
+DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "amerknife", 150, DOD_KILLS_WITH_AMERKNIFE );
+DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "spade", 150, DOD_KILLS_WITH_SPADE );
+DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "punch", 150, DOD_KILLS_WITH_PUNCH );
+
+DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "frag_us", 250, DOD_KILLS_WITH_FRAG_US );
+DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "frag_ger", 250, DOD_KILLS_WITH_FRAG_GER );
+DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "riflegren_us", 250, DOD_KILLS_WITH_RIFLEGREN_US );
+DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "riflegren_ger", 250, DOD_KILLS_WITH_RIFLEGREN_GER );
+
+
+// flag captures
+class CAchievementDODFlagCaptureGrind : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 100 );
+		SetStoreProgressInSteam( true );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "dod_point_captured" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		Assert( FStrEq( event->GetName(), "dod_point_captured" ) );
+
+		if ( event->GetBool( "bomb" ) == true )
+			return;
+
+		if ( !GameRulesAllowsAchievements() )
+			return;
+
+		C_DODPlayer *pPlayer = C_DODPlayer::GetLocalDODPlayer();
+		if ( !pPlayer )
+			return;
+
+		int iLocalPlayerIndex = pPlayer->entindex();
+
+		const char *cappers = event->GetString("cappers");
+
+		int len = Q_strlen(cappers);
+		for( int i=0;i<len;i++ )
+		{
+			if ( iLocalPlayerIndex == (int)cappers[i] )
+			{
+				IncrementCount();
+				break;
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementDODFlagCaptureGrind, ACHIEVEMENT_DOD_CAPTURE_GRIND, "DOD_CAPTURE_GRIND", 1 );
+
+
+class CAchievementDODBlockCapturesGrind : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 100 );
+		SetStoreProgressInSteam( true );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "dod_capture_blocked" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( !GameRulesAllowsAchievements() )
+			return;
+
+		Assert( FStrEq( event->GetName(), "dod_capture_blocked" ) );
+
+		if ( event->GetBool( "bomb" ) )
+			return;
+
+		C_DODPlayer *pPlayer = C_DODPlayer::GetLocalDODPlayer();
+
+		if ( pPlayer && pPlayer->entindex() == event->GetInt( "blocker" ) )
+		{
+			IncrementCount();
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementDODBlockCapturesGrind, ACHIEVEMENT_DOD_BLOCK_CAPTURES_GRIND, "DOD_BLOCK_CAPTURES_GRIND", 1 );
+
+
+class CAchievementDODRoundsWonGrind : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 100 );
+		SetStoreProgressInSteam( true );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "dod_round_win" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( !GameRulesAllowsAchievements() )
+			return;
+
+		Assert( FStrEq( event->GetName(), "dod_round_win" ) );
+
+		C_DODPlayer *pPlayer = C_DODPlayer::GetLocalDODPlayer();
+		if ( !pPlayer )
+			return;
+
+		if ( event->GetInt( "team" ) == pPlayer->GetTeamNumber() )
+		{
+			IncrementCount();
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementDODRoundsWonGrind, ACHIEVEMENT_DOD_ROUNDS_WON_GRIND, "DOD_ROUNDS_WON_GRIND", 1 );
+
+
+class CAchievementDODBombsPlantedGrind : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 100 );
+		SetStoreProgressInSteam( true );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "dod_bomb_planted" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		Assert( FStrEq( event->GetName(), "dod_bomb_planted" ) );
+
+		C_DODPlayer *pPlayer = C_DODPlayer::GetLocalDODPlayer();
+
+		if ( pPlayer && pPlayer->GetUserID() == event->GetInt("userid" ) )
+		{
+			IncrementCount();
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementDODBombsPlantedGrind, ACHIEVEMENT_DOD_BOMBS_PLANTED_GRIND, "DOD_BOMBS_PLANTED_GRIND", 1 );
+
+
+class CAchievementDODBombsDefusedGrind : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 100 );
+		SetStoreProgressInSteam( true );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "dod_bomb_defused" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		Assert( FStrEq( event->GetName(), "dod_bomb_defused" ) );
+
+		if ( event->GetInt("userid") == C_BasePlayer::GetLocalPlayer()->GetUserID() )
+		{
+			IncrementCount();
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementDODBombsDefusedGrind, ACHIEVEMENT_DOD_BOMBS_DEFUSED_GRIND, "DOD_BOMBS_DEFUSED_GRIND", 1 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementDOD_All_Pack_1 : public CAchievement_AchievedCount
+{
+public:
+	DECLARE_CLASS( CAchievementDOD_All_Pack_1, CAchievement_AchievedCount );
+	void Init() 
+	{
+		BaseClass::Init();
+		SetAchievementsRequired( 51, 0, 51 );
+	}
+
+	// Complete all dod achievements
+};
+DECLARE_ACHIEVEMENT( CAchievementDOD_All_Pack_1, ACHIEVEMENT_DOD_ALL_PACK_1, "DOD_ALL_PACK_1", 5 );
+
+
+// 2011 Summer sale achievement
+// Win a round on each of the winter themed maps, dod_kalt and dod_colmar
+// player is not required to have been present at the start of the round
+class CAchievementDODBeatTheHeat : public CBaseAchievement
+{
+public:
+	DECLARE_CLASS( CAchievementDODBeatTheHeat, CBaseAchievement );
+	void Init()
+	{
+		SetFlags( ACH_SAVE_GLOBAL | ACH_HAS_COMPONENTS );	
+		
+		static const char *szComponents[] =
+		{
+			"dod_kalt", "dod_colmar"
+		};	
+		m_pszComponentNames = szComponents;
+		m_iNumComponents = ARRAYSIZE( szComponents );
+		SetGoal( m_iNumComponents ); 
+
+		BaseClass::Init();
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "dod_round_win" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( !GameRulesAllowsAchievements() )
+			return;
+
+		Assert( FStrEq( event->GetName(), "dod_round_win" ) );
+
+		C_DODPlayer *pPlayer = C_DODPlayer::GetLocalDODPlayer();
+		if ( !pPlayer )
+			return;
+
+		if ( event->GetInt( "team" ) == pPlayer->GetTeamNumber() )
+		{
+			OnComponentEvent( m_pAchievementMgr->GetMapName() );
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementDODBeatTheHeat, ACHIEVEMENT_DOD_BEAT_THE_HEAT, "DOD_BEAT_THE_HEAT", 1 );
+
+// Winter 2011
+class CAchievementDODCollectHolidayGifts : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 3 );
+		SetStoreProgressInSteam( true );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "christmas_gift_grab" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+	//	if ( !UTIL_IsHolidayActive( kHoliday_Christmas ) )
+	//		return;
+
+		if ( Q_strcmp( event->GetName(), "christmas_gift_grab" ) == 0 )
+		{
+			int iPlayer = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
+			CBaseEntity *pPlayer = UTIL_PlayerByIndex( iPlayer );
+
+			if ( pPlayer && pPlayer == C_DODPlayer::GetLocalDODPlayer() )
+			{
+				IncrementCount();
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementDODCollectHolidayGifts, ACHIEVEMENT_DOD_COLLECT_HOLIDAY_GIFTS, "DOD_COLLECT_HOLIDAY_GIFTS", 5 );
+
+#endif // CLIENT_DLL

game/shared/dod/dod_gamerules.h

@@ -0,0 +1,526 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: The TF Game rules object
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef DOD_GAMERULES_H
+#define DOD_GAMERULES_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "teamplay_gamerules.h"
+#include "convar.h"
+#include "dod_shareddefs.h"
+#include "gamevars_shared.h"
+#include "weapon_dodbase.h"
+#include "dod_round_timer.h"
+
+#ifdef CLIENT_DLL
+	#include "c_baseplayer.h"
+#else
+	#include "player.h"
+	#include "dod_player.h"
+	#include "utlqueue.h"
+	#include "playerclass_info_parse.h"
+	#include "voice_gamemgr.h"
+	#include "dod_gamestats.h"
+#endif
+
+#ifdef CLIENT_DLL
+	#define CDODGameRules C_DODGameRules
+	#define CDODGameRulesProxy C_DODGameRulesProxy
+#else
+	extern IVoiceGameMgrHelper *g_pVoiceGameMgrHelper;
+	extern IUploadGameStats *gamestatsuploader;
+#endif
+
+#ifndef CLIENT_DLL
+
+	class CSpawnPoint : public CPointEntity
+	{
+	public:
+		bool IsDisabled() { return m_bDisabled; }
+		void InputEnable( inputdata_t &inputdata ) { m_bDisabled = false; }
+		void InputDisable( inputdata_t &inputdata ) { m_bDisabled = true; }
+
+	private:
+		bool m_bDisabled;
+		DECLARE_DATADESC();
+	};
+
+#endif
+
+class CDODGameRulesProxy : public CGameRulesProxy
+{
+public:
+	DECLARE_CLASS( CDODGameRulesProxy, CGameRulesProxy );
+	DECLARE_NETWORKCLASS();
+};
+
+class CDODGameRules;
+
+class CDODRoundStateInfo
+{
+public:
+	DODRoundState m_iRoundState;
+	const char *m_pStateName;
+	
+	void (CDODGameRules::*pfnEnterState)();	// Init and deinit the state.
+	void (CDODGameRules::*pfnLeaveState)();
+	void (CDODGameRules::*pfnThink)();	// Do a PreThink() in this state.
+};
+
+typedef enum
+{
+	STARTROUND_ATTACK = 0,
+	STARTROUND_DEFEND,
+
+	STARTROUND_BEACH,
+
+	STARTROUND_ATTACK_TIMED,
+	STARTROUND_DEFEND_TIMED,
+
+	STARTROUND_FLAGS,
+} startround_voice_t;
+ 
+class CDODGamePlayRules
+{
+public:
+	DECLARE_CLASS_NOBASE( CDODGamePlayRules );
+	DECLARE_EMBEDDED_NETWORKVAR();
+
+	DECLARE_SIMPLE_DATADESC();
+
+	CDODGamePlayRules()
+	{
+		Reset();
+	}
+
+	// This virtual method is necessary to generate a vtable in all cases
+	// (DECLARE_PREDICTABLE will generate a vtable also)!
+	virtual ~CDODGamePlayRules() {}
+
+	void Reset( void )
+	{
+		//RespawnFactor	
+		m_fAlliesRespawnFactor	= 1.0f;
+		m_fAxisRespawnFactor	= 1.0f;
+	}
+	
+	//Respawn Factors
+	float			m_fAlliesRespawnFactor;	//How delayed are respawning players 
+	float			m_fAxisRespawnFactor;	//1.0 is normal, 2.0 is twice as long
+
+	int				m_iAlliesStartRoundVoice;	// Which voice to play at round start
+	int				m_iAxisStartRoundVoice;
+};
+
+
+//Mapper interface for gamerules
+class CDODDetect : public CBaseEntity
+{
+public:
+	DECLARE_CLASS( CDODDetect, CBaseEntity );
+
+	CDODDetect();
+	void Spawn( void );
+	virtual bool KeyValue( const char *szKeyName, const char *szValue );
+
+	bool IsMasteredOn( void );
+
+	inline CDODGamePlayRules *GetGamePlay() { return &m_GamePlayRules; }
+	CDODGamePlayRules m_GamePlayRules;
+
+private:
+//	string_t m_sMaster;
+};
+
+class CDODViewVectors : public CViewVectors
+{
+public:
+	CDODViewVectors( 
+		Vector vView,
+		Vector vHullMin,
+		Vector vHullMax,
+		Vector vDuckHullMin,
+		Vector vDuckHullMax,
+		Vector vDuckView,
+		Vector vObsHullMin,
+		Vector vObsHullMax,
+		Vector vDeadViewHeight,
+		Vector vProneHullMin,
+		Vector vProneHullMax ) :
+			CViewVectors( 
+				vView,
+				vHullMin,
+				vHullMax,
+				vDuckHullMin,
+				vDuckHullMax,
+				vDuckView,
+				vObsHullMin,
+				vObsHullMax,
+				vDeadViewHeight )
+	{
+		m_vProneHullMin = vProneHullMin;
+		m_vProneHullMax = vProneHullMax;
+	}
+
+	Vector m_vProneHullMin;
+	Vector m_vProneHullMax;	
+};
+
+//GAMERULES
+class CDODGameRules : public CTeamplayRules
+{
+public:
+	DECLARE_CLASS( CDODGameRules, CTeamplayRules );
+
+	virtual bool ShouldCollide( int collisionGroup0, int collisionGroup1 );
+
+	inline DODRoundState State_Get( void ) { return m_iRoundState; }
+
+	int GetSubTeam( int team );
+
+	bool IsGameUnderTimeLimit( void );
+	int GetTimeLeft( void );
+
+	int GetReinforcementTimerSeconds( int team, float flSpawnEligibleTime );
+
+	bool IsFriendlyFireOn( void );
+	bool IsInBonusRound( void );
+
+	// Get the view vectors for this mod.
+	virtual const CViewVectors* GetViewVectors() const;
+	virtual const CDODViewVectors *GetDODViewVectors() const;
+	virtual const unsigned char *GetEncryptionKey( void ) { return (unsigned char *)"Wl0u5B3F"; }
+
+	bool AwaitingReadyRestart( void ) { return m_bAwaitingReadyRestart; }
+	float GetRoundRestartTime( void ) { return m_flRestartRoundTime; }
+
+	bool IsInWarmup( void ) { return m_bInWarmup; }
+
+	bool IsBombingTeam( int team );
+
+	virtual bool IsConnectedUserInfoChangeAllowed( CBasePlayer *pPlayer );
+
+#ifndef CLIENT_DLL
+	float GetPresentDropChance( void );	// holiday 2011, presents instead of ammo boxes
+#endif
+
+#ifdef CLIENT_DLL
+
+	DECLARE_CLIENTCLASS_NOBASE(); // This makes datatables able to access our private vars.
+
+	void SetRoundState( int iRoundState );
+	float m_flLastRoundStateChangeTime;
+
+#else
+
+	DECLARE_SERVERCLASS_NOBASE(); // This makes datatables able to access our private vars.
+
+	CDODGameRules();
+	virtual ~CDODGameRules();
+
+	virtual void LevelShutdown( void );
+	void UploadLevelStats( void );
+
+	virtual bool ClientCommand( CBaseEntity *pEdict, const CCommand &args );
+	virtual void RadiusDamage( const CTakeDamageInfo &info, const Vector &vecSrc, float flRadius, int iClassIgnore, CBaseEntity *pEntityIgnore );
+	virtual void RadiusDamage( const CTakeDamageInfo &info, const Vector &vecSrcIn, float flRadius, int iClassIgnore, CBaseEntity *pEntityIgnore, bool bIgnoreWorld = false );
+	void RadiusStun( const CTakeDamageInfo &info, const Vector &vecSrc, float flRadius );
+	virtual void Think();
+	virtual void PlayerKilled( CBasePlayer *pVictim, const CTakeDamageInfo &info );
+	virtual void ClientDisconnected( edict_t *pClient );
+	virtual float FlPlayerFallDamage( CBasePlayer *pPlayer );
+
+	virtual const char *GetGameDescription( void )
+	{
+		return "Day of Defeat: Source";
+	}
+
+	void CreateStandardEntities( void );
+
+	virtual const char *GetChatPrefix( bool bTeamOnly, CBasePlayer *pPlayer );
+	
+	CBaseEntity *GetPlayerSpawnSpot( CBasePlayer *pPlayer );
+	bool IsSpawnPointValid( CBaseEntity *pSpot, CBasePlayer *pPlayer );
+	virtual void PlayerSpawn( CBasePlayer *pPlayer );
+
+	int DODPointsForKill( CBasePlayer *pVictim, const CTakeDamageInfo &info );
+
+	//Round state machine
+	void State_Transition( DODRoundState newState );
+	void State_Enter( DODRoundState newState );	// Initialize the new state.
+	void State_Leave();							// Cleanup the previous state.
+	void State_Think();						// Update the current state.
+
+	CDODRoundStateInfo *m_pCurStateInfo;	//Fn ptrs for the current state
+	float m_flStateTransitionTime;			//Timer for round states
+	
+	// Find the state info for the specified state.
+	static CDODRoundStateInfo* State_LookupInfo( DODRoundState state );
+
+	//State Functions
+	void State_Enter_INIT( void );
+	void State_Think_INIT( void );
+
+	void State_Enter_PREGAME( void );
+	void State_Think_PREGAME( void );
+
+	void State_Enter_STARTGAME( void );
+	void State_Think_STARTGAME( void );
+
+	void State_Enter_PREROUND( void );
+	void State_Think_PREROUND( void );
+
+	void State_Enter_RND_RUNNING( void );
+	void State_Think_RND_RUNNING( void );
+
+	void State_Enter_ALLIES_WIN( void );
+	void State_Think_ALLIES_WIN( void );
+
+	void State_Enter_AXIS_WIN( void );
+	void State_Think_AXIS_WIN( void );
+
+	void State_Enter_RESTART( void );
+	void State_Think_RESTART( void );
+
+	void SetInWarmup( bool bWarmup );
+	void CheckWarmup( void );
+	void CheckRestartRound( void );
+	void CheckRespawnWaves( void );
+
+	void InitTeams( void );
+
+	void RoundRespawn( void );
+	void CleanUpMap( void );
+	void ResetScores( void );
+
+	// Respawn everyone regardless of state - round reset
+	inline void RespawnAllPlayers( void ) { RespawnPlayers( true ); }
+
+	// Respawn only one team, players that are ready to spawn - wave reset
+	inline void RespawnTeam( int iTeam ) { RespawnPlayers( false, true, iTeam ); }
+
+	void RespawnPlayers( bool bForceRespawn, bool bTeam = false, int iTeam = TEAM_UNASSIGNED );
+
+	void FailSafeSpawnPlayersOnTeam( int iTeam );
+
+	bool IsPlayerClassOnTeam( int cls, int team );
+	bool CanPlayerJoinClass( CDODPlayer *pPlayer, int cls );
+	void ChooseRandomClass( CDODPlayer *pPlayer );
+	bool ReachedClassLimit( int team, int cls );
+	int CountPlayerClass( int team, int cls );
+	int GetClassLimit( int team, int cls );
+
+	int CountActivePlayers( void );	//How many players have chosen a team?
+
+	void SetWinningTeam( int team );
+	void PlayWinSong( int team );
+	void PlayStartRoundVoice( void );
+	void BroadcastSound( const char *sound );
+	void PlaySpawnSoundToTeam( const char *sound, int team );
+
+	int SelectDefaultTeam( void );
+
+	void CopyGamePlayLogic( const CDODGamePlayRules otherGamePlay );
+
+
+	void DeathNotice( CBasePlayer *pVictim, const CTakeDamageInfo &info );
+
+	virtual bool CanHavePlayerItem( CBasePlayer *pPlayer, CBaseCombatWeapon *pWeapon );
+
+	bool TeamFull( int team_id );
+	bool TeamStacked( int iNewTeam, int iCurTeam );
+
+	const char *GetPlayerClassName( int cls, int team );
+
+	virtual void ClientSettingsChanged( CBasePlayer *pPlayer );
+
+	void CheckChatForReadySignal( CDODPlayer *pPlayer, const char *chatmsg );
+	bool AreAlliesReady( void ) { return m_bHeardAlliesReady; }
+	bool AreAxisReady( void ) { return m_bHeardAxisReady; }
+
+	void CreateOrJoinRespawnWave( CDODPlayer *pPlayer );
+	
+	virtual bool InRoundRestart( void );
+
+	void SendTeamScoresEvent( void );
+
+	void WriteStatsFile( const char *pszLogName );
+
+	void AddTimerSeconds( int iSecondsToAdd );
+	int GetTimerSeconds( void );
+
+	void CapEvent( int event, int team );
+	int m_iLastAlliesCapEvent;
+	int m_iLastAxisCapEvent;
+
+	// Set the time at which the map was reset to 'now'
+	// and send an event with the time remaining until map change
+	void ResetMapTime( void );
+
+	virtual CBaseCombatWeapon *GetNextBestWeapon( CBaseCombatCharacter *pPlayer, CBaseCombatWeapon *pCurrentWeapon );
+
+	virtual bool CanEntityBeUsePushed( CBaseEntity *pEnt );
+
+	virtual void CalcDominationAndRevenge( CDODPlayer *pAttacker, CDODPlayer *pVictim, int *piDeathFlags );
+
+	float m_flNextFailSafeWaveCheckTime;
+
+	CUtlVector<EHANDLE> *GetSpawnPointListForTeam( int iTeam );
+
+	virtual void GetTaggedConVarList( KeyValues *pCvarTagList );
+
+protected:	
+	virtual void GoToIntermission( void );
+	virtual bool UseSuicidePenalty() { return false; }
+
+	void CheckPlayerPositions( void );
+
+private:
+	bool CheckTimeLimit( void );
+	bool CheckWinLimit( void );
+
+	void RadiusDamage( const CTakeDamageInfo &info, const Vector &vecSrcIn, float flRadius, int iClassIgnore, bool bIgnoreWorld );
+	float GetExplosionDamageAdjustment(Vector & vecSrc, Vector & vecEnd, CBaseEntity *pTarget, CBaseEntity *pEntityToIgnore); // returns multiplier between 0.0 and 1.0 that is the percentage of any damage done from vecSrc to vecEnd that actually makes it.
+	float GetAmountOfEntityVisible(Vector & src, CBaseEntity *pTarget, CBaseEntity *pEntityToIgnore); // returns a value from 0 to 1 that is the percentage of player visible from src.
+
+	void CheckLevelInitialized( void );
+	bool m_bLevelInitialized;
+
+	int	m_iSpawnPointCount_Allies;	//number of allies spawns on the map
+	int	m_iSpawnPointCount_Axis;	//number of axis spawns on the map
+
+	#define MAX_PLAYERCLASSES_PER_TEAM	16
+
+	PLAYERCLASS_FILE_INFO_HANDLE m_hPlayerClassInfoHandles[2][MAX_PLAYERCLASSES_PER_TEAM];
+
+	// restart and warmup variables
+	float m_flWarmupTimeEnds;
+	float m_flNextPeriodicThink;
+
+	Vector2D	m_vecPlayerPositions[MAX_PLAYERS];
+	
+
+	//BELOW HERE NEED TO BE HOOKED UP
+
+
+	int				m_iNumAlliesAlive;	//the number of players alive on each team
+	int				m_iNumAxisAlive;
+	int				m_iNumAlliesOnTeam;	//the number of players on each team
+	int				m_iNumAxisOnTeam;
+
+	bool			m_bClanMatch;
+	bool			m_bClanMatchActive;
+
+	float			GetMaxWaveTime( int iTeam );
+	float			GetWaveTime( int iTeam );
+	void 			AddWaveTime( int team, float flTime );
+	void 			PopWaveTime( int team );
+
+	void DetectGameRules( void );
+
+	bool m_bHeardAlliesReady;
+	bool m_bHeardAxisReady;
+
+	bool m_bUsingTimer;
+	int m_iTimerWinTeam;
+	CHandle< CDODRoundTimer >	m_pRoundTimer;
+
+	bool m_bPlayTimerWarning_1Minute;
+	bool m_bPlayTimerWarning_2Minute;
+
+	bool m_bInitialSpawn;	// first time activating? longer wait time for people to join
+
+	bool m_bChangeLevelOnRoundEnd;
+
+#endif	//CLIENT_DLL
+
+	CNetworkVarEmbedded( CDODGamePlayRules, m_GamePlayRules );
+
+	CNetworkVar( DODRoundState, m_iRoundState );
+
+	#define DOD_RESPAWN_QUEUE_SIZE	10
+
+	CNetworkArray( float, m_AlliesRespawnQueue, DOD_RESPAWN_QUEUE_SIZE );
+	CNetworkArray( float, m_AxisRespawnQueue, DOD_RESPAWN_QUEUE_SIZE );
+
+	CNetworkVar( int, m_iAlliesRespawnHead );
+	CNetworkVar( int, m_iAlliesRespawnTail );
+
+	CNetworkVar( int, m_iAxisRespawnHead );
+	CNetworkVar( int, m_iAxisRespawnTail );
+
+	int m_iNumAlliesRespawnWaves;
+	int m_iNumAxisRespawnWaves;
+
+	CNetworkVar( bool, m_bInWarmup );
+	CNetworkVar( bool, m_bAwaitingReadyRestart );
+	CNetworkVar( float, m_flRestartRoundTime );
+	CNetworkVar( float, m_flMapResetTime );	// time that the map was reset
+
+	CNetworkVar( bool, m_bAlliesAreBombing );
+	CNetworkVar( bool, m_bAxisAreBombing );
+
+#ifndef CLIENT_DLL
+public:
+	// Stats
+	void Stats_PlayerKill( int team, int cls );
+	void Stats_PlayerCap( int team, int cls );
+	void Stats_PlayerDefended( int team, int cls );
+	void Stats_WeaponFired( int weaponID );
+	void Stats_WeaponHit( int weaponID, float flDist );
+	int Stats_WeaponDistanceToBucket( int weaponID, float flDist );
+
+	float m_flSecondsPlayedPerClass_Allies[7];
+	float m_flSecondsPlayedPerClass_Axis[7];
+
+	int m_iStatsKillsPerClass_Allies[6];
+	int m_iStatsKillsPerClass_Axis[6];
+
+	int m_iStatsSpawnsPerClass_Allies[6];
+	int m_iStatsSpawnsPerClass_Axis[6];
+
+	int m_iStatsCapsPerClass_Allies[6];
+	int m_iStatsCapsPerClass_Axis[6];
+
+	int m_iStatsDefensesPerClass_Allies[6];
+	int m_iStatsDefensesPerClass_Axis[6];
+
+	int m_iWeaponShotsFired[WEAPON_MAX];
+	int m_iWeaponShotsHit[WEAPON_MAX];
+	int m_iWeaponDistanceBuckets[WEAPON_MAX][DOD_NUM_WEAPON_DISTANCE_BUCKETS];	// distances of buckets are defined per-weapon
+
+	// List of spawn points
+	CUtlVector<EHANDLE> m_AlliesSpawnPoints;
+	CUtlVector<EHANDLE> m_AxisSpawnPoints;
+
+	bool m_bWinterHolidayActive;
+
+#endif // ndef CLIENTDLL
+};
+
+//-----------------------------------------------------------------------------
+// Gets us at the team fortress game rules
+//-----------------------------------------------------------------------------
+
+inline CDODGameRules* DODGameRules()
+{
+	return static_cast<CDODGameRules*>(g_pGameRules);
+}
+
+#ifdef CLIENT_DLL
+
+#else	
+	bool EntityPlacementTest( CBaseEntity *pMainEnt, const Vector &vOrigin, Vector &outPos, bool bDropToGround );
+#endif //CLIENT_DLL
+
+
+#endif // DOD_GAMERULES_H

game/shared/dod/dod_player_shared.h

@@ -0,0 +1,285 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef DOD_PLAYER_SHARED_H
+#define DOD_PLAYER_SHARED_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "networkvar.h"
+#include "weapon_dodbase.h"
+
+
+#ifdef CLIENT_DLL
+	class C_DODPlayer;
+#else
+	class CDODPlayer;
+#endif
+
+// Entity Messages
+#define DOD_PLAYER_POP_HELMET		1
+#define DOD_PLAYER_REMOVE_DECALS	2
+
+class CViewOffsetAnimation
+{
+public:
+	CViewOffsetAnimation( CBasePlayer *pPlayer )
+	{
+		m_pPlayer = pPlayer;
+		m_vecStart = vec3_origin;
+		m_vecDest = vec3_origin;
+		m_flLength = 0.0;
+		m_flEndTime = 0.0;
+		m_eViewAnimType = VIEW_ANIM_LINEAR_Z_ONLY;
+		m_bActive = false;
+	}
+
+	static CViewOffsetAnimation *CreateViewOffsetAnim( CBasePlayer *pPlayer )
+	{
+		CViewOffsetAnimation *p = new CViewOffsetAnimation( pPlayer );
+
+		Assert( p );
+
+		return p;
+	}
+
+	void StartAnimation( Vector vecStart, Vector vecDest, float flTime, ViewAnimationType type )
+	{
+		m_vecStart = vecStart;
+		m_vecDest = vecDest;
+		m_flLength = flTime;
+		m_flEndTime = gpGlobals->curtime + flTime;
+		m_eViewAnimType = type;
+		m_bActive = true;
+	}
+
+	void Reset( void ) 
+	{
+		m_bActive = false;
+	}
+
+	void Think( void )
+	{
+		if ( !m_bActive )
+			return;
+
+		if ( IsFinished() )
+		{
+			m_bActive = false;
+			return;
+		}
+
+		float flFraction = ( m_flEndTime - gpGlobals->curtime ) / m_flLength;
+
+		Assert( m_pPlayer );
+
+		if ( m_pPlayer )
+		{
+			Vector vecCurrentView = m_pPlayer->GetViewOffset();
+
+			switch ( m_eViewAnimType )
+			{
+			case VIEW_ANIM_LINEAR_Z_ONLY:
+				vecCurrentView.z = flFraction * m_vecStart.z + ( 1.0 - flFraction ) * m_vecDest.z;
+				break;
+
+			case VIEW_ANIM_SPLINE_Z_ONLY:
+				vecCurrentView.z = SimpleSplineRemapVal( flFraction, 1.0, 0.0, m_vecStart.z, m_vecDest.z );
+				break;
+
+			case VIEW_ANIM_EXPONENTIAL_Z_ONLY:
+				{
+					float flBias = Bias( flFraction, 0.2 );
+					vecCurrentView.z = flBias * m_vecStart.z + ( 1.0 - flBias ) * m_vecDest.z;
+				}
+				break;
+			}
+
+			m_pPlayer->SetViewOffset( vecCurrentView );
+		}		
+	}
+
+	bool IsFinished( void )
+	{
+		return ( gpGlobals->curtime > m_flEndTime || m_pPlayer == NULL );
+	}
+
+private:
+	CBasePlayer *m_pPlayer;
+	Vector		m_vecStart;
+	Vector		m_vecDest;
+	float		m_flEndTime;
+	float		m_flLength;
+	ViewAnimationType m_eViewAnimType;
+	bool		m_bActive;
+};
+
+
+// Data in the DoD player that is accessed by shared code.
+// This data isn't necessarily transmitted between client and server.
+class CDODPlayerShared
+{
+public:
+
+#ifdef CLIENT_DLL
+	friend class C_DODPlayer;
+	typedef C_DODPlayer OuterClass;
+	DECLARE_PREDICTABLE();
+#else
+	friend class CDODPlayer;
+	typedef CDODPlayer OuterClass;
+#endif
+	
+	DECLARE_EMBEDDED_NETWORKVAR()
+	DECLARE_CLASS_NOBASE( CDODPlayerShared );
+
+
+	CDODPlayerShared();
+	~CDODPlayerShared();
+
+	void	SetStamina( float stamina );
+	float	GetStamina( void ) { return m_flStamina; }
+	
+	void	Init( OuterClass *pOuter );
+
+	bool	IsProne() const;
+	bool	IsGettingUpFromProne() const;	
+	bool	IsGoingProne() const;
+	void	SetProne( bool bProne, bool bNoAnimation = false );
+
+	bool	IsBazookaDeployed( void ) const;
+	bool	IsBazookaOnlyDeployed( void ) const;
+	bool	IsSniperZoomed( void ) const;
+	bool	IsInMGDeploy( void ) const;
+	bool	IsProneDeployed( void ) const;
+	bool	IsSandbagDeployed( void ) const;
+	bool	IsDucking( void ) const; 
+	
+	void	SetDesiredPlayerClass( int playerclass );
+	int		DesiredPlayerClass( void );
+
+	void	SetPlayerClass( int playerclass );
+	int		PlayerClass( void );
+
+	CWeaponDODBase* GetActiveDODWeapon() const;
+
+	void	SetDeployed( bool bDeployed, float flHeight = -1 );
+
+	QAngle	GetDeployedAngles( void ) const;
+	float	GetDeployedHeight( void ) const;
+
+	void	SetDeployedYawLimits( float flLeftYaw, float flRightYaw );
+	void	ClampDeployedAngles( QAngle *vecTestAngles );
+
+	void	SetSlowedTime( float t );
+	float	GetSlowedTime( void ) const;
+
+	void	StartGoingProne( void );
+	void	StandUpFromProne( void );
+
+	bool	CanChangePosition( void );
+
+	bool	IsJumping( void ) { return m_bJumping; }
+	void	SetJumping( bool bJumping );
+
+	bool	IsSprinting( void ) { return m_bIsSprinting; }
+
+	void	ForceUnzoom( void );
+
+	void	SetSprinting( bool bSprinting );
+	void	StartSprinting( void );
+	void	StopSprinting( void );
+
+	void	SetCPIndex( int index );
+	int		GetCPIndex( void ) { return m_iCPIndex; }
+
+	void SetLastViewAnimTime( float flTime );
+	float GetLastViewAnimTime( void );
+
+	void ViewAnimThink( void );
+
+	void ResetViewOffsetAnimation( void );
+	void ViewOffsetAnimation( Vector vecDest, float flTime, ViewAnimationType type );
+
+	void ResetSprintPenalty( void );
+
+	void SetPlanting( bool bPlanting )
+	{
+		m_bPlanting = bPlanting;
+	}
+
+	bool IsPlanting( void ) { return m_bPlanting; } 
+
+	void SetDefusing( bool bDefusing )
+	{
+		m_bDefusing = bDefusing;
+	}
+
+	bool IsDefusing( void ) { return m_bDefusing; }
+
+	void ComputeWorldSpaceSurroundingBox( Vector *pVecWorldMins, Vector *pVecWorldMaxs );
+
+	void	SetPlayerDominated( CDODPlayer *pPlayer, bool bDominated );
+	bool	IsPlayerDominated( int iPlayerIndex );
+	bool	IsPlayerDominatingMe( int iPlayerIndex );
+	void	SetPlayerDominatingMe( CDODPlayer *pPlayer, bool bDominated );
+
+private:
+
+	CNetworkVar( bool, m_bProne );
+
+	CNetworkVar( int, m_iPlayerClass );
+	CNetworkVar( int, m_iDesiredPlayerClass );
+
+	CNetworkVar( float, m_flStamina );
+
+	CNetworkVar( float, m_flSlowedUntilTime );
+
+	CNetworkVar( bool, m_bIsSprinting );
+
+	CNetworkVar( float, m_flDeployedYawLimitLeft );
+	CNetworkVar( float, m_flDeployedYawLimitRight );
+
+	CNetworkVar( bool, m_bPlanting );
+	CNetworkVar( bool, m_bDefusing );
+
+	bool m_bGaveSprintPenalty;
+
+public:
+	float m_flNextProneCheck; // Prevent it switching their prone state constantly.
+
+	QAngle m_vecDeployedAngles;
+	//float m_flDeployedHeight;
+	CNetworkVar( float, m_flDeployedHeight );
+
+	CNetworkVar( float, m_flUnProneTime );
+	CNetworkVar( float, m_flGoProneTime );
+
+	CNetworkVar( float, m_flDeployChangeTime );
+	
+	CNetworkVar( bool, m_bForceProneChange );
+
+	CNetworkVar( int, m_iCPIndex );
+
+	bool m_bJumping;
+
+	float m_flLastViewAnimationTime;
+
+	CViewOffsetAnimation *m_pViewOffsetAnim;
+
+	CNetworkArray( bool, m_bPlayerDominated, MAX_PLAYERS+1 );		// array of state per other player whether player is dominating other players
+	CNetworkArray( bool, m_bPlayerDominatingMe, MAX_PLAYERS+1 );	// array of state per other player whether other players are dominating this player
+
+private:
+	
+	OuterClass *m_pOuter;
+};			   
+
+
+
+#endif // DOD_PLAYER_SHARED_H

game/shared/dod/dod_playeranimstate.h

@@ -0,0 +1,62 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef DOD_PLAYERANIMSTATE_H
+#define DOD_PLAYERANIMSTATE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "convar.h"
+#include "iplayeranimstate.h"
+
+
+#if defined( CLIENT_DLL )
+	class C_DODPlayer;
+	#define CDODPlayer C_DODPlayer
+#else
+	class CDODPlayer;
+#endif
+
+enum PlayerAnimEvent_t
+{
+	PLAYERANIMEVENT_FIRE_GUN=0,
+	PLAYERANIMEVENT_THROW_GRENADE,
+	PLAYERANIMEVENT_ROLL_GRENADE,
+	PLAYERANIMEVENT_JUMP,
+	PLAYERANIMEVENT_RELOAD,
+	PLAYERANIMEVENT_SECONDARY_ATTACK,
+	PLAYERANIMEVENT_HANDSIGNAL,
+	PLAYERANIMEVENT_PLANT_TNT,
+	PLAYERANIMEVENT_DEFUSE_TNT,
+
+	PLAYERANIMEVENT_HS_NONE,
+	PLAYERANIMEVENT_CANCEL_GESTURES,	// cancel current gesture
+
+	PLAYERANIMEVENT_COUNT
+};
+
+class IDODPlayerAnimState : virtual public IPlayerAnimState
+{
+public:
+	// This is called by both the client and the server in the same way to trigger events for
+	// players firing, jumping, throwing grenades, etc.
+	virtual void DoAnimationEvent( PlayerAnimEvent_t event, int nData = 0 ) = 0;
+
+	virtual void ShowDebugInfo( void ) = 0;
+};
+
+
+IDODPlayerAnimState* CreatePlayerAnimState( CDODPlayer *pPlayer );
+
+
+// If this is set, then the game code needs to make sure to send player animation events
+// to the local player if he's the one being watched.
+extern ConVar cl_showanimstate;
+
+
+#endif // DOD_PLAYERANIMSTATE_H

game/shared/dod/dod_playerclass_info_parse.cpp

@@ -0,0 +1,163 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "dod_playerclass_info_parse.h"
+#include "dod_shareddefs.h"
+#include "weapon_dodbase.h"
+#include <KeyValues.h>
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+FilePlayerClassInfo_t* CreatePlayerClassInfo()
+{
+	return new CDODPlayerClassInfo;
+}
+
+CDODPlayerClassInfo::CDODPlayerClassInfo()
+{
+	m_iTeam= TEAM_UNASSIGNED;
+	
+	m_iPrimaryWeapon= WEAPON_NONE;
+	m_iSecondaryWeapon= WEAPON_NONE;
+	m_iMeleeWeapon= WEAPON_NONE;
+	
+	m_iNumGrensType1 = 0;
+	m_iGrenType1 = WEAPON_NONE;
+
+	m_iNumGrensType2 = 0;
+	m_iGrenType2 = WEAPON_NONE;
+
+	m_iNumBandages = 0;
+		
+	m_iHelmetGroup= HELMET_GROUP_0;
+	m_iHairGroup= HELMET_GROUP_0;
+
+	m_iDropHelmet = HELMET_ALLIES;
+
+	m_szLimitCvar[0] = '\0';
+	m_bClassLimitMGMerge = false;
+}
+
+int AliasToWeaponID( const char *alias )
+{
+	if (alias)
+	{
+		for( int i=0; s_WeaponAliasInfo[i] != NULL; ++i )
+			if (!Q_stricmp( s_WeaponAliasInfo[i], alias ))
+				return i;
+	}
+
+	return WEAPON_NONE;
+}
+
+void CDODPlayerClassInfo::Parse( KeyValues *pKeyValuesData, const char *szWeaponName )
+{
+	BaseClass::Parse( pKeyValuesData, szWeaponName );
+
+	m_iTeam= pKeyValuesData->GetInt( "team", TEAM_UNASSIGNED );
+
+	// Figure out what team can have this player class
+	m_iTeam = TEAM_UNASSIGNED;
+	const char *pTeam = pKeyValuesData->GetString( "team", NULL );
+	if ( pTeam )
+	{
+		if ( Q_stricmp( pTeam, "ALLIES" ) == 0 )
+		{
+			m_iTeam = TEAM_ALLIES;
+		}
+		else if ( Q_stricmp( pTeam, "AXIS" ) == 0 )
+		{
+			m_iTeam = TEAM_AXIS;
+		}
+		else
+		{
+			Assert( false );
+		}
+	}
+	else
+	{
+		Assert( false );
+	}
+	
+	const char *pszPrimaryWeapon = pKeyValuesData->GetString( "primaryweapon", NULL );
+	m_iPrimaryWeapon = AliasToWeaponID( pszPrimaryWeapon );
+	Assert( m_iPrimaryWeapon != WEAPON_NONE );	// require player to have a primary weapon
+
+	const char *pszSecondaryWeapon = pKeyValuesData->GetString( "secondaryweapon", NULL );
+
+	if ( pszSecondaryWeapon )
+	{
+        m_iSecondaryWeapon = AliasToWeaponID( pszSecondaryWeapon );
+		Assert( m_iSecondaryWeapon != WEAPON_NONE );
+	}
+	else 
+		m_iSecondaryWeapon = WEAPON_NONE;
+
+	const char *pszMeleeWeapon = pKeyValuesData->GetString( "meleeweapon", NULL );
+	if ( pszMeleeWeapon )
+	{
+		m_iMeleeWeapon = AliasToWeaponID( pszMeleeWeapon );
+        Assert( m_iMeleeWeapon != WEAPON_NONE );
+	}
+	else
+		m_iMeleeWeapon = WEAPON_NONE;
+
+	m_iNumGrensType1 = pKeyValuesData->GetInt( "numgrens", 0 );
+	if ( m_iNumGrensType1 > 0 )
+	{
+		const char *pszGrenType1 = pKeyValuesData->GetString( "grenadetype", NULL );
+		m_iGrenType1 = AliasToWeaponID( pszGrenType1 );
+		Assert( m_iGrenType1 != WEAPON_NONE );
+	}
+
+	m_iNumGrensType2 = pKeyValuesData->GetInt( "numgrens2", 0 );
+	if ( m_iNumGrensType2 > 0 )
+	{
+		const char *pszGrenType2 = pKeyValuesData->GetString( "grenadetype2", NULL );
+		m_iGrenType2 = AliasToWeaponID( pszGrenType2 );
+		Assert( m_iGrenType2 != WEAPON_NONE );
+	}
+
+	m_iNumBandages = pKeyValuesData->GetInt( "numbandages", 0 );
+
+	m_iHelmetGroup	= pKeyValuesData->GetInt( "helmetgroup", 0 );
+	m_iHairGroup	= pKeyValuesData->GetInt( "hairgroup", 0 );
+
+	// Which helmet model to generate 
+	const char *pszHelmetModel = pKeyValuesData->GetString( "drophelmet", "HELMET_ALLIES" );
+
+	if( pszHelmetModel )
+	{
+		if ( Q_stricmp( pszHelmetModel, "HELMET_ALLIES" ) == 0 )
+		{
+			m_iDropHelmet = HELMET_ALLIES;
+		}
+		else if ( Q_stricmp( pszHelmetModel, "HELMET_AXIS" ) == 0 )
+		{
+			m_iDropHelmet = HELMET_AXIS;
+		}
+		else
+		{
+			Assert( false );
+		}
+	}
+	else
+	{
+		Assert( false );
+	}
+
+	Q_strncpy( m_szLimitCvar, pKeyValuesData->GetString( "limitcvar", "!! Missing limit cvar on Player Class" ), sizeof(m_szLimitCvar) );
+
+	Assert( Q_strlen( m_szLimitCvar ) > 0 && "Every class must specify a limitcvar" );
+
+	m_bClassLimitMGMerge = ( pKeyValuesData->GetInt( "mergemgclass" ) > 0 );
+
+	// HUD player status health images (when the player is hurt)
+	Q_strncpy( m_szClassHealthImage, pKeyValuesData->GetString( "healthimage", "white" ), sizeof( m_szClassHealthImage ) );
+	Q_strncpy( m_szClassHealthImageBG, pKeyValuesData->GetString( "healthimagebg", "white" ), sizeof( m_szClassHealthImageBG ) );
+}

game/shared/dod/dod_playerclass_info_parse.h

@@ -0,0 +1,55 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef DOD_PLAYERCLASS_INFO_PARSE_H
+#define DOD_PLAYERCLASS_INFO_PARSE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "playerclass_info_parse.h"
+#include "networkvar.h"
+#include "dod_shareddefs.h"
+
+//--------------------------------------------------------------------------------------------------------
+class CDODPlayerClassInfo : public FilePlayerClassInfo_t
+{
+public:
+	DECLARE_CLASS_GAMEROOT( CDODPlayerClassInfo, FilePlayerClassInfo_t );
+	
+	CDODPlayerClassInfo();
+	
+	virtual void Parse( ::KeyValues *pKeyValuesData, const char *szWeaponName );
+
+	int m_iTeam;		//which team. 2 == allies, 3 == axis
+
+	int m_iPrimaryWeapon;
+	int m_iSecondaryWeapon;
+	int m_iMeleeWeapon;
+
+	int m_iNumGrensType1;
+	int m_iGrenType1;
+
+	int m_iNumGrensType2;
+	int m_iGrenType2;
+
+	int m_iNumBandages;
+
+	int m_iHelmetGroup;
+	int m_iHairGroup;	//what helmet group to switch to when the helmet comes off
+
+	int m_iDropHelmet;
+
+	char m_szLimitCvar[64];	//which cvar controls the class limit for this class
+	bool m_bClassLimitMGMerge;	// merge class limits with this set to true
+
+	char m_szClassHealthImage[DOD_HUD_HEALTH_IMAGE_LENGTH];
+	char m_szClassHealthImageBG[DOD_HUD_HEALTH_IMAGE_LENGTH];
+};
+
+
+#endif // DOD_PLAYERCLASS_INFO_PARSE_H

game/shared/dod/dod_round_timer.cpp

@@ -0,0 +1,183 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Dod gamerules round timer 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "dod_round_timer.h"
+
+#ifdef CLIENT_DLL
+
+	#include "iclientmode.h"
+	#include "vgui_controls/AnimationController.h"
+
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#ifdef CLIENT_DLL
+
+	// Use this proxy to flash the round timer whenever the timer is restarted
+	// because trapping the round start event doesn't work ( the event also flushes
+	// all hud events and obliterates our TimerFlash event )
+	static void RecvProxy_TimerPaused( const CRecvProxyData *pData, void *pStruct, void *pOut )
+	{
+		CDODRoundTimer *pTimer = (CDODRoundTimer *) pStruct;
+
+		bool bTimerPaused = ( pData->m_Value.m_Int > 0 );
+
+		if ( bTimerPaused == false )
+		{
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "TimerFlash" ); 
+		}
+
+		pTimer->InternalSetPaused( bTimerPaused );
+	}
+
+#endif
+
+LINK_ENTITY_TO_CLASS( dod_round_timer, CDODRoundTimer );
+
+IMPLEMENT_NETWORKCLASS_ALIASED( DODRoundTimer, DT_DODRoundTimer )
+
+BEGIN_NETWORK_TABLE_NOBASE( CDODRoundTimer, DT_DODRoundTimer )
+	#ifdef CLIENT_DLL
+
+		RecvPropInt( RECVINFO( m_bTimerPaused ), 0, RecvProxy_TimerPaused ),
+		RecvPropTime( RECVINFO( m_flTimeRemaining ) ),
+		RecvPropTime( RECVINFO( m_flTimerEndTime ) ),
+
+	#else
+
+		SendPropBool( SENDINFO( m_bTimerPaused ) ),
+		SendPropTime( SENDINFO( m_flTimeRemaining ) ),
+		SendPropTime( SENDINFO( m_flTimerEndTime ) ),
+
+	#endif
+END_NETWORK_TABLE()
+
+#ifdef CLIENT_DLL
+	CDODRoundTimer *g_DODRoundTimer = NULL;
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: constructor
+//-----------------------------------------------------------------------------
+CDODRoundTimer::CDODRoundTimer( void )
+{
+#ifndef CLIENT_DLL
+	m_bTimerPaused = true;
+	m_flTimeRemaining = 0;
+	m_iTimerMaxLength = 0;
+#else
+	g_DODRoundTimer = this;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: destructor
+//-----------------------------------------------------------------------------
+CDODRoundTimer::~CDODRoundTimer( void )
+{
+#ifdef CLIENT_DLL
+	g_DODRoundTimer = NULL;
+#endif
+}
+
+#ifndef CLIENT_DLL
+
+//-----------------------------------------------------------------------------
+// Purpose: The timer is always transmitted to clients
+//-----------------------------------------------------------------------------
+int CDODRoundTimer::UpdateTransmitState()
+{
+	// ALWAYS transmit to all clients.
+	return SetTransmitState( FL_EDICT_ALWAYS );
+}
+
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: To set the initial timer duration
+//-----------------------------------------------------------------------------
+void CDODRoundTimer::SetTimeRemaining( int iTimerSeconds )
+{
+	m_flTimeRemaining = (float)iTimerSeconds;
+	m_flTimerEndTime = gpGlobals->curtime + m_flTimeRemaining;
+	m_iTimerMaxLength = iTimerSeconds;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Timer is paused at round end, stops the countdown
+//-----------------------------------------------------------------------------
+void CDODRoundTimer::PauseTimer( void )
+{
+	if ( m_bTimerPaused == false )
+	{
+		m_bTimerPaused = true;
+
+		m_flTimeRemaining = m_flTimerEndTime - gpGlobals->curtime;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: To start or re-start the timer after a pause
+//-----------------------------------------------------------------------------
+void CDODRoundTimer::ResumeTimer( void )
+{
+	if ( m_bTimerPaused == true )
+	{
+		m_bTimerPaused = false;
+
+		m_flTimerEndTime = gpGlobals->curtime + m_flTimeRemaining;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Gets the seconds left on the timer, paused or not.
+//-----------------------------------------------------------------------------
+float CDODRoundTimer::GetTimeRemaining( void )
+{
+	float flSecondsRemaining;
+
+	if ( m_bTimerPaused )
+	{
+		flSecondsRemaining = m_flTimeRemaining;
+	}
+	else
+	{
+		flSecondsRemaining = m_flTimerEndTime - gpGlobals->curtime;
+	}
+
+	if ( flSecondsRemaining < 0 )
+		flSecondsRemaining = 0;
+
+	return flSecondsRemaining;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Add seconds to the timer while it is running or paused
+//-----------------------------------------------------------------------------
+void CDODRoundTimer::AddTimerSeconds( int iSecondsToAdd )
+{
+	// do a hud animation indicating that time has been added
+
+	if ( m_bTimerPaused )
+	{
+		m_flTimeRemaining += (float)iSecondsToAdd;
+	}
+	else
+	{
+		m_flTimerEndTime += (float)iSecondsToAdd;
+	}
+
+	m_iTimerMaxLength += iSecondsToAdd;
+}
+
+int CDODRoundTimer::GetTimerMaxLength( void )
+{
+	return m_iTimerMaxLength;
+}

game/shared/dod/dod_round_timer.h

@@ -0,0 +1,67 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Round timer for dod gamerules
+//
+//=============================================================================//
+
+#ifndef DOD_ROUND_TIMER_H
+#define DOD_ROUND_TIMER_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#ifdef CLIENT_DLL
+	#define CDODRoundTimer C_DODRoundTimer
+#endif
+
+class CDODRoundTimer : public CBaseEntity
+{
+public:
+	DECLARE_CLASS( CDODRoundTimer, CBaseEntity );
+	DECLARE_NETWORKCLASS();
+
+	// Constructor
+	CDODRoundTimer();
+
+	// Destructor
+	virtual ~CDODRoundTimer();
+
+	// Set the initial length of the timer
+	void SetTimeRemaining( int iTimerSeconds );
+
+	// Add time to an already running ( or paused ) timer
+	void AddTimerSeconds( int iSecondsToAdd );
+
+	void PauseTimer( void );
+	void ResumeTimer( void );
+
+	// Returns seconds to display.
+	// When paused shows amount of time left once the timer is resumed
+	float GetTimeRemaining( void );
+
+	int GetTimerMaxLength( void );
+
+#ifndef CLIENT_DLL
+
+	int UpdateTransmitState();
+
+#else
+
+	void InternalSetPaused( bool bPaused ) { m_bTimerPaused = bPaused; }
+
+#endif	
+
+private:
+	CNetworkVar( bool, m_bTimerPaused );
+	CNetworkVar( float, m_flTimeRemaining );
+	CNetworkVar( float, m_flTimerEndTime );
+
+	int m_iTimerMaxLength;	// Sum of starting duration plus any time we added
+};
+
+#ifdef CLIENT_DLL
+	extern CDODRoundTimer *g_DODRoundTimer;
+#endif
+
+#endif	//DOD_ROUND_TIMER_H

game/shared/dod/dod_shareddefs.cpp

@@ -0,0 +1,276 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+#include "cbase.h"
+#include "dod_shareddefs.h"
+#include "weapon_dodbase.h"
+
+//Voice commands
+DodVoiceCommand_t g_VoiceCommands[] =
+{
+	//Voice command			// Command Name		//HS								//Allied subtitle					//german subtitle					//brit subtitle
+
+	// Menu A
+	{"voice_attack",		"Moveout",			PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_attack",			"#Voice_subtitle_moveout"},
+	{"voice_hold",			"Hold",				PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_hold" },
+	{"voice_left",			"FlankLeft",		PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_left" },
+	{"voice_right",			"FlankRight",		PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_right" },
+	{"voice_sticktogether",	"StickTogether",	PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_sticktogether" },
+	{"voice_cover",			"CoveringFire",		PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_cover" },
+	{"voice_usesmoke",		"UseSmoke",			PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_usesmoke" },
+	{"voice_usegrens",		"UseGrenades",		PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_usegrens" },
+	{"voice_ceasefire",		"CeaseFire",		PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_ceasefire" },
+			
+	// Menu B
+	{"voice_yessir",		"YesSir",			PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_yessir" },
+	{"voice_negative",		"Negative",			PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_negative" },
+	{"voice_backup",		"BackUp",			PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_backup" },
+	{"voice_fireinhole",	"FireInHole",		PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_fireinhole" },
+	{"voice_grenade",		"Grenade",			PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_grenade" },
+	{"voice_sniper",		"Sniper",			PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_sniper" },
+	{"voice_niceshot",		"NiceShot",			PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_niceshot" },
+	{"voice_thanks",		"Thanks",			PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_thanks" },
+	{"voice_areaclear",		"Clear",			PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_areaclear" },
+			
+	// Menu C
+	{"voice_dropweapons",	"DropWeapons",		PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_dropyourweapons" },
+	{"voice_displace",		"Displace",			PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_displace" },
+	{"voice_mgahead",		"MgAhead",			PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_mgahead" },
+	{"voice_enemybehind",	"BehindUs",			PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_enemybehind" },
+	{"voice_wegothim",		"WeGotHim",			PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_wegothim" },
+	{"voice_moveupmg",		"MoveUpMg",			PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_moveupmg_30cal",	"#Voice_subtitle_moveupmg_mg",		"#Voice_subtitle_moveupmg_bren"},
+	{"voice_needammo",		"NeedAmmo",			PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_needammo" },
+	{"voice_usebazooka",	"UseRocket",		PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_usebazooka",		"#Voice_subtitle_usepschreck",		"#Voice_subtitle_usepiat"},
+	{"voice_bazookaspotted","RocketSpotted",	PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_pschreckspotted",	"#Voice_subtitle_bazookaspotted",	"#Voice_subtitle_pschreckspotted"},
+
+	// Voice commands that aren't in a menu
+	{"voice_gogogo",		"Moveout",			PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_attack",			"#Voice_subtitle_moveout"},
+	{"voice_medic",			"Medic",			PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_medic" },
+	{"voice_coverflanks",	"CoverFlanks",		PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_coverflanks" },
+	{"voice_tank",			"TankAhead",		PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_tigerahead",		"#Voice_subtitle_tankahead*" },
+	{"voice_takeammo",		"TakeAmmo",			PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_takeammo" },
+	{"voice_movewithtank",	"MoveWithTank",		PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_movewithtank" },
+	{"voice_wtf",			"WhiskeyTangoFoxtrot",	PLAYERANIMEVENT_HANDSIGNAL,		"#Voice_subtitle_wtf" },
+	{"voice_fireleft",		"TakingFireLeft",	PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_fireleft" },
+	{"voice_fireright",		"TakingFireRight",	PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_fireright" },
+	{"voice_mgahead",		"MgAhead",			PLAYERANIMEVENT_HANDSIGNAL,			"#Voice_subtitle_mgahead" },
+	{"voice_enemyahead",	"EnemyAhead",		PLAYERANIMEVENT_HANDSIGNAL,		"#Voice_subtitle_enemyahead" },
+	{"voice_fallback",		"FallBack",			PLAYERANIMEVENT_HANDSIGNAL,		"#Voice_subtitle_fallback" },
+	
+	// Must be last in the list
+	{ NULL }
+};
+
+// Hand Signals
+DodHandSignal_t g_HandSignals[] =
+{
+	//command					// anim event						//subtitle
+
+	{"signal_sticktogether",	PLAYERANIMEVENT_HANDSIGNAL,		"#Voice_subtitle_sticktogether" },
+	{"signal_fallback",			PLAYERANIMEVENT_HANDSIGNAL,		"#Voice_subtitle_fallback" },
+	{"signal_no",				PLAYERANIMEVENT_HANDSIGNAL,		"#Voice_subtitle_negative" },
+	{"signal_yes",				PLAYERANIMEVENT_HANDSIGNAL,		"#Voice_subtitle_yessir" },
+	{"signal_sniper",			PLAYERANIMEVENT_HANDSIGNAL,		"#Voice_subtitle_sniper" },
+	{"signal_backup",			PLAYERANIMEVENT_HANDSIGNAL,		"#Voice_subtitle_backup" },
+	{"signal_enemyleft",		PLAYERANIMEVENT_HANDSIGNAL,		"#Voice_subtitle_fireleft" },
+	{"signal_enemyright",		PLAYERANIMEVENT_HANDSIGNAL,		"#Voice_subtitle_fireright" },
+	{"signal_grenade",			PLAYERANIMEVENT_HANDSIGNAL,		"#Voice_subtitle_grenade" },
+	{"signal_flankleft",		PLAYERANIMEVENT_HANDSIGNAL,		"#Voice_subtitle_left" },
+	{"signal_flankright",		PLAYERANIMEVENT_HANDSIGNAL,		"#Voice_subtitle_right" },
+	{"signal_moveout",			PLAYERANIMEVENT_HANDSIGNAL,		"#Voice_subtitle_attack" },
+	{"signal_areaclear",		PLAYERANIMEVENT_HANDSIGNAL,		"#Voice_subtitle_areaclear" },
+	{"signal_coveringfire",		PLAYERANIMEVENT_HANDSIGNAL,		"#Voice_subtitle_cover" },
+								
+	// Must be last in the list
+	{ NULL }
+};
+
+const char * s_WeaponAliasInfo[] = 
+{
+	"none",	//	WEAPON_NONE = 0,
+
+	//Melee
+	"amerknife",	//WEAPON_AMERKNIFE,
+	"spade",		//WEAPON_SPADE,
+
+	//Pistols
+	"colt",			//WEAPON_COLT,
+	"p38",			//WEAPON_P38,
+	"c96",			//WEAPON_C96
+
+	//Rifles
+	"garand",		//WEAPON_GARAND,
+	"m1carbine",	//WEAPON_M1CARBINE,
+	"k98",			//WEAPON_K98,
+	
+	//Sniper Rifles
+	"spring",		//WEAPON_SPRING,
+	"k98_scoped",	//WEAPON_K98_SCOPED,
+
+	//SMG
+	"thompson",		//WEAPON_THOMPSON,
+	"mp40",			//WEAPON_MP40,
+	"mp44",			//WEAPON_MP44,
+	"bar",			//WEAPON_BAR,
+
+	//Machine guns
+	"30cal",		//WEAPON_30CAL,
+	"mg42",			//WEAPON_MG42,
+
+	//Rocket weapons
+	"bazooka",		//WEAPON_BAZOOKA,
+	"pschreck",		//WEAPON_PSCHRECK,
+
+	//Grenades
+	"frag_us",		//WEAPON_FRAG_US,
+	"frag_ger",		//WEAPON_FRAG_GER,
+
+	"frag_us_live",		//WEAPON_FRAG_US_LIVE
+	"frag_ger_live",	//WEAPON_FRAG_GER_LIVE
+
+	"smoke_us",			//WEAPON_SMOKE_US
+	"smoke_ger",		//WEAPON_SMOKE_GER
+
+	"riflegren_us",	//WEAPON_RIFLEGREN_US
+	"riflegren_ger",	//WEAPON_RIFLEGREN_GER
+
+	"riflegren_us_live",	//WEAPON_RIFLEGREN_US_LIVE
+	"riflegren_ger_live",		//WEAPON_RIFLEGREN_GER_LIVE
+
+	// not actually separate weapons, but defines used in stats recording
+	"thompson_punch",		//WEAPON_THOMPSON_PUNCH
+	"mp40_punch",			//WEAPON_MP40_PUNCH
+	"garand_zoomed",		//WEAPON_GARAND_ZOOMED,	
+
+	"k98_zoomed",			//WEAPON_K98_ZOOMED
+	"spring_zoomed",		//WEAPON_SPRING_ZOOMED
+	"k98s_zoomed",			//WEAPON_K98_SCOPED_ZOOMED	
+
+	"30cal_undeployed",		//WEAPON_30CAL_UNDEPLOYED,
+	"mg42_undeployed",		//WEAPON_MG42_UNDEPLOYED,
+
+	"bar_semiauto",			//WEAPON_BAR_SEMIAUTO,
+	"mp44_semiauto",		//WEAPON_MP44_SEMIAUTO,
+	
+	NULL,		// end of list marker
+};
+
+const char *m_pszHelmetModels[NUM_HELMETS] =
+{
+	"models/helmets/helmet_american.mdl",
+	"models/helmets/helmet_german.mdl",
+};
+
+const char *g_pszHintMessages[] =
+{
+	"#Hint_spotted_a_friend",
+	"#Hint_spotted_an_enemy",
+	"#Hint_try_not_to_injure_teammates",
+	"#Hint_careful_around_teammates",
+	"#Hint_killing_enemies_is_good",
+	"#Hint_touched_area_capture",
+	"#Hint_touched_control_point",
+	"#Hint_picked_up_object",
+	"#Hint_mgs_fire_better_deployed",
+	"#Hint_sandbag_area_touch",
+	"#Hint_rocket_weapon_pickup",
+	"#Hint_out_of_ammo",
+	"#Hint_prone",
+	"#Hint_low_stamina",
+	"#Hint_area_requires_object",
+	"#Hint_player_killed_wavetime", 
+	"#Hint_mg_overheat",
+	"#game_shoulder_rpg",
+	"#Hint_pick_up_weapon",
+	"#Hint_pick_up_grenade",
+	"#Hint_death_cam",
+	"#Hint_class_menu",
+	"#Hint_use_2e_melee",
+	"#Hint_use_zoom",
+	"#Hint_use_iron_sights",
+	"#Hint_use_semi_auto",
+	"#Hint_use_sprint",
+	"#Hint_use_deploy",
+	"#Hint_use_prime",
+	"#Hint_mg_deploy_usage",
+	"#Dod_mg_reload",
+	"#Hint_garand_reload",
+	"#Hint_turn_off_hints",
+	"#Hint_need_bomb_to_plant",
+	"#Hint_bomb_planted",
+	"#Hint_defuse_bomb",
+	"#Hint_bomb_target",
+	"#Hint_bomb_pickup",
+	"#Hint_bomb_defuse_onground",
+	"#Hint_bomb_plant_map",
+	"#Hint_bomb_first_select",
+};
+
+const char *pszTeamAlliesClasses[] = 
+{
+	"us_garand",
+	"us_tommy",
+	"us_bar",
+	"us_spring",
+	"us_30cal",
+	"us_bazooka",
+	NULL
+};
+
+const char *pszTeamAxisClasses[] = 
+{
+	"axis_k98",
+	"axis_mp40",
+	"axis_mp44",
+	"axis_k98s",
+	"axis_mg42",
+	"axis_pschreck",
+	NULL
+};
+
+const char *pszWinPanelCategoryHeaders[] =
+{
+	"",
+	"#winpanel_topbomb",
+	"#winpanel_topcappers",
+	"#winpanel_topdefenders",
+	"#winpanel_kills"
+};
+
+const char *g_pszAchievementAwards[NUM_ACHIEVEMENT_AWARDS] =
+{
+	"",
+	"DOD_KILLS_AS_RIFLEMAN",
+	"DOD_KILLS_AS_ASSAULT",
+	"DOD_KILLS_AS_SUPPORT",
+	"DOD_KILLS_AS_SNIPER",
+	"DOD_KILLS_AS_MG",
+	"DOD_KILLS_AS_BAZOOKAGUY",
+	"DOD_ALL_PACK_1",
+};
+
+const char *g_pszAchievementAwardMaterials_Allies[NUM_ACHIEVEMENT_AWARDS] =
+{
+	"sprites/player_icons/american",
+	"sprites/player_icons/american_rifleman",
+	"sprites/player_icons/american_assault",
+	"sprites/player_icons/american_support",
+	"sprites/player_icons/american_sniper",
+	"sprites/player_icons/american_mg",
+	"sprites/player_icons/american_rocket",
+	"sprites/player_icons/american_hero",
+};
+
+const char *g_pszAchievementAwardMaterials_Axis[NUM_ACHIEVEMENT_AWARDS] =
+{
+	"sprites/player_icons/german",
+	"sprites/player_icons/german_rifleman",
+	"sprites/player_icons/german_assault",
+	"sprites/player_icons/german_support",
+	"sprites/player_icons/german_sniper",
+	"sprites/player_icons/german_mg",
+	"sprites/player_icons/german_rocket",
+	"sprites/player_icons/german_hero",
+};

game/shared/dod/dod_shareddefs.h

@@ -0,0 +1,691 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef DOD_SHAREDDEFS_H
+#define DOD_SHAREDDEFS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "dod_playeranimstate.h"
+
+
+#define DOD_PLAYER_VIEW_OFFSET	Vector( 0, 0, 54 )
+
+// DOD Team IDs.
+#define TEAM_ALLIES			2
+#define	TEAM_AXIS			3
+#define TEAM_MAXCOUNT		4	// update this if we ever add teams (unlikely)
+
+enum SubTeam
+{
+	SUBTEAM_NORMAL = 0,
+	SUBTEAM_PARA,
+	SUBTEAM_ALT_NATION,
+	NUM_SUBTEAMS
+};
+
+#define MAX_CONTROL_POINTS 8
+#define MAX_CONTROL_POINT_GROUPS	8
+
+#define DEATH_CAM_TIME	5.0f
+
+#define MAX_WAVE_RESPAWN_TIME	20.0f
+
+#define DOD_BOMB_TIMER_LENGTH	20
+#define DOD_BOMB_DEFUSE_TIME	3.0f
+#define DOD_BOMB_PLANT_TIME		2.0f
+#define DOD_BOMB_PLANT_RADIUS	80
+#define DOD_BOMB_DEFUSE_MAXDIST 96.0f
+
+enum
+{
+	CAP_EVENT_NONE,
+	CAP_EVENT_BOMB,
+	CAP_EVENT_FLAG,
+	CAP_EVENT_TIMER_EXPIRE
+};
+
+enum
+{
+	WINPANEL_TOP3_NONE,
+	WINPANEL_TOP3_BOMBERS,
+	WINPANEL_TOP3_CAPPERS,
+	WINPANEL_TOP3_DEFENDERS,
+	WINPANEL_TOP3_KILLERS
+};
+
+//--------------
+// DoD Specific damage flags
+//--------------	
+
+// careful when reusing HL2 DMG_ flags, some of them cancel out the damage, eg if they are in DMG_TIMEBASED
+
+#define DMG_STUN			(DMG_PARALYZE)				//(1<<15)
+#define DMG_MACHINEGUN		(DMG_LASTGENERICFLAG<<1)	//(1<<30)
+#define DMG_BOMB			(DMG_LASTGENERICFLAG<<2)	//(1<<31)
+
+//END OF THE EXTENDABLE LIST!! Start reusing HL2 specific flags
+
+#define MELEE_DMG_SECONDARYATTACK	(1<<0)
+#define MELEE_DMG_FIST				(1<<1)
+#define MELEE_DMG_EDGE				(1<<2)
+#define MELEE_DMG_STRONGATTACK		(1<<3)
+
+#define SANDBAG_NOT_TOUCHING		0
+#define SANDBAG_TOUCHING			1
+#define SANDBAG_TOUCHING_ALIGNED	2
+#define SANDBAG_DEPLOYED			3
+
+#define PRONE_DEPLOY_HEIGHT	-1
+
+#define STANDING_DEPLOY_HEIGHT	58
+#define CROUCHING_DEPLOY_HEIGHT	28
+#define TIME_TO_DEPLOY 0.3
+
+#define MIN_DEPLOY_PITCH	45
+#define MAX_DEPLOY_PITCH	-60
+
+#define VEC_DUCK_MOVING_HULL_MIN	Vector(-16, -16, 0 )
+#define VEC_DUCK_MOVING_HULL_MAX	Vector( 16,  16, 55 )
+
+#define VEC_PRONE_HULL_MIN	DODGameRules()->GetDODViewVectors()->m_vProneHullMin
+#define VEC_PRONE_HULL_MAX	DODGameRules()->GetDODViewVectors()->m_vProneHullMax	// MUST be shorter than duck hull for deploy check
+
+#define VEC_PRONE_HULL_MIN_SCALED( player )	( DODGameRules()->GetDODViewVectors()->m_vProneHullMin * player->GetModelScale() )
+#define VEC_PRONE_HULL_MAX_SCALED( player )	( DODGameRules()->GetDODViewVectors()->m_vProneHullMax * player->GetModelScale() )
+
+#define VEC_PRONE_HELPER_HULL_MIN	Vector(-48, -48, 0 )
+#define VEC_PRONE_HELPER_HULL_MAX	Vector( 48,  48,  24 )
+
+#define GRENADE_FUSE_LENGTH	5.0
+#define RIFLEGRENADE_FUSE_LENGTH 3.5
+
+#define CONTENTS_PRONE_HELPER			0x80000000
+
+#define PASS_OUT_CHANGE_TIME	1.5
+#define PASS_OUT_GET_UP_TIME	1.5
+
+// DOD-specific viewport panels
+#define PANEL_TEAM				"team"
+#define PANEL_CLASS_ALLIES		"class_us"
+#define PANEL_CLASS_AXIS		"class_ger"
+#define PANEL_BACKGROUND		"background"
+
+#define COLOR_DOD_GREEN	Color(77, 121, 66, 255) //	Color(76, 102, 76, 255)
+#define COLOR_DOD_RED	Color(255, 64, 64, 255)
+
+#define DOD_HUD_HEALTH_IMAGE_LENGTH 64
+
+// The various states the player can be in during the join game process.
+enum DODPlayerState
+{
+	// Happily running around in the game.
+	// This state can jump to a bunch of other states like STATE_PICKINGCLASS or STATE_DEATH_ANIM.
+	STATE_ACTIVE=0,
+	
+	// This is the state you're in when you first enter the server.
+	// It's switching between intro cameras every few seconds, and there's a level info 
+	// screen up.
+	STATE_WELCOME,			// Show the level intro screen.
+	
+	// During these states, you can either be a new player waiting to join, or
+	// you can be a live player in the game who wants to change teams.
+	// Either way, you can't move while choosing team or class (or while any menu is up).
+	STATE_PICKINGTEAM,			// Choosing team.
+	STATE_PICKINGCLASS,			// Choosing class.
+	
+	STATE_DEATH_ANIM,			// Playing death anim, waiting for that to finish.
+	STATE_DEATH_OBSERVING,		// Done playing death anim. Waiting for keypress to go into observer mode.
+	STATE_OBSERVER_MODE,		// Noclipping around, watching players, etc.
+
+	NUM_PLAYER_STATES
+};
+
+enum DODRoundState
+{
+	// initialize the game, create teams
+	STATE_INIT=0,
+
+	//Before players have joined the game. Periodically checks to see if enough players are ready
+	//to start a game. Also reverts to this when there are no active players
+	STATE_PREGAME,
+
+	//The game is about to start, wait a bit and spawn everyone
+	STATE_STARTGAME,
+
+	//All players are respawned, frozen in place
+	STATE_PREROUND,
+
+	//Round is on, playing normally
+	STATE_RND_RUNNING,
+
+	//Someone has won the round
+	STATE_ALLIES_WIN,
+	STATE_AXIS_WIN,
+
+	//Noone has won, manually restart the game, reset scores
+	STATE_RESTART,
+
+	//Game is over, showing the scoreboard etc
+	STATE_GAME_OVER,
+
+	NUM_ROUND_STATES
+};
+
+#define PLAYERCLASS_RANDOM		-2
+#define PLAYERCLASS_UNDEFINED	-1
+
+#define DOD_PLAYERMODEL_AXIS_RIFLEMAN	"models/player/german_rifleman.mdl"	
+#define DOD_PLAYERMODEL_AXIS_ASSAULT	"models/player/german_assault.mdl"	
+#define DOD_PLAYERMODEL_AXIS_SUPPORT	"models/player/german_support.mdl"
+#define DOD_PLAYERMODEL_AXIS_SNIPER		"models/player/german_sniper.mdl"
+#define DOD_PLAYERMODEL_AXIS_MG			"models/player/german_mg.mdl"	
+#define DOD_PLAYERMODEL_AXIS_ROCKET		"models/player/german_rocket.mdl"	
+
+#define DOD_PLAYERMODEL_US_RIFLEMAN		"models/player/american_rifleman.mdl"
+#define DOD_PLAYERMODEL_US_ASSAULT		"models/player/american_assault.mdl"
+#define DOD_PLAYERMODEL_US_SUPPORT		"models/player/american_support.mdl"
+#define DOD_PLAYERMODEL_US_SNIPER		"models/player/american_sniper.mdl"	
+#define DOD_PLAYERMODEL_US_MG			"models/player/american_mg.mdl"
+#define DOD_PLAYERMODEL_US_ROCKET		"models/player/american_rocket.mdl"
+
+typedef struct DodClassInfo_s
+{
+	char selectcmd[32];
+	char classname[128];
+	char modelname[128];
+
+	int team;		//which team. 0 == allies, 1 == axis
+
+	int primarywpn;
+	int secondarywpn;
+	int meleewpn;
+
+	int numgrenades;
+	int armskin;	//what skin does this class show in grenades / knives
+
+	int headgroup;	//bodygroups
+	int helmetgroup;
+	int geargroup;
+	int bodygroup;
+	int hairgroup;	//what helmet group to switch to when the helmet comes off
+	
+} DodClassInfo_t;
+
+extern DodClassInfo_t g_ClassInfo[];	//a structure to hold all of the classes
+extern DodClassInfo_t g_ParaClassInfo[];
+
+// Voice Commands
+typedef struct DodVoiceCommand_s
+{
+	const char *pszCommandName;	// console command that will produce the voice command
+
+	const char *pszSoundName;		// name of sound to play
+
+	PlayerAnimEvent_t iHandSignal;		//index into the hand signal array
+
+	const char *pszAlliedSubtitle;	// subtitles for each nationality
+	const char *pszAxisSubtitle;
+	const char *pszBritishSubtitle;
+	
+} DodVoiceCommand_t;
+
+extern DodVoiceCommand_t g_VoiceCommands[];
+
+// Hand Signals
+typedef struct DodHandSignal_s
+{
+	const char *pszCommandName;	// console command that will produce the voice command
+
+	PlayerAnimEvent_t iHandSignal;		//index into the hand signal array
+
+	const char *pszSubtitle;	// subtitles for each nationality
+
+} DodHandSignal_t;
+
+extern DodHandSignal_t g_HandSignals[];
+
+#define ARM_SKIN_UNDEFINED 0
+
+enum
+{
+	HEAD_GROUP_0 = 0,
+	HEAD_GROUP_1,
+	HEAD_GROUP_2,
+	HEAD_GROUP_3,
+	HEAD_GROUP_4,
+	HEAD_GROUP_5,
+	HEAD_GROUP_6,
+};
+
+enum
+{
+	HELMET_GROUP_0 = 0,
+	HELMET_GROUP_1,
+	HELMET_GROUP_2,
+	HELMET_GROUP_3,
+	HELMET_GROUP_4,
+	HELMET_GROUP_5,
+	HELMET_GROUP_6,
+	HELMET_GROUP_7,
+};
+
+enum
+{
+	BODY_GROUP_0 = 0,
+	BODY_GROUP_1,
+	BODY_GROUP_2,
+	BODY_GROUP_3,
+	BODY_GROUP_4,
+	BODY_GROUP_5,
+};
+
+enum
+{
+	GEAR_GROUP_0 = 0,
+	GEAR_GROUP_1,
+	GEAR_GROUP_2,
+	GEAR_GROUP_3,
+	GEAR_GROUP_4,
+	GEAR_GROUP_5,
+	GEAR_GROUP_6,
+};
+
+enum
+{
+	BODYGROUP_BODY = 0,
+	BODYGROUP_HELMET,
+	BODYGROUP_HEAD,
+	BODYGROUP_GEAR,
+	BODYGROUP_JUMPGEAR
+};
+
+enum
+{
+	BODYGROUP_HEAD1 = 0,
+	BODYGROUP_HEAD2,
+	BODYGROUP_HEAD3,
+	BODYGROUP_HEAD4,
+	BODYGROUP_HEAD5,
+	BODYGROUP_HEAD6,
+	BODYGROUP_HEAD7
+};
+
+//helmet groups
+#define BODYGROUP_HELMET_ON 0
+
+#define BODYGROUP_ALLIES_HELMET_HELMET1 0
+#define BODYGROUP_ALLIES_HELMET_HELMET2 1
+#define BODYGROUP_ALLIES_HELMET_OFF 2
+
+#define BODYGROUP_AXIS_HAIR0	1
+#define BODYGROUP_AXIS_HAIR1	2
+#define BODYGROUP_AXIS_HAIR2	3
+#define BODYGROUP_AXIS_HAIR3	4
+#define BODYGROUP_AXIS_HAIR4	5
+#define BODYGROUP_AXIS_HAIR5	6
+#define BODYGROUP_AXIS_HAIR6	7
+
+//battle gear groups
+#define BODYGROUP_TOMMYGEAR			0
+#define BODYGROUP_SPRINGGEAR		1
+#define BODYGROUP_GARANDGEAR		2
+#define BODYGROUP_MGGEAR			3
+#define BODYGROUP_BARGEAR			4
+#define BODYGROUP_CARBGEAR			5
+#define BODYGROUP_GREASEGUNGEAR		6
+
+//jump gear
+#define BODYGROUP_JUMPGEAR_OFF 0
+#define BODYGROUP_JUMPGEAR_ON 1
+
+enum
+{
+	HELMET_ALLIES = 0,
+	HELMET_AXIS,
+
+	NUM_HELMETS
+};
+
+extern const char *m_pszHelmetModels[NUM_HELMETS];
+
+//Materials
+/*
+#define CHAR_TEX_CONCRETE	'C'			// texture types
+#define CHAR_TEX_METAL		'M'
+#define CHAR_TEX_DIRT		'D'
+#define CHAR_TEX_GRATE		'G'
+#define CHAR_TEX_TILE		'T'
+#define CHAR_TEX_WOOD		'W'
+#define CHAR_TEX_GLASS		'Y'
+#define CHAR_TEX_FLESH		'F'
+#define CHAR_TEX_WATER		'S'
+#define CHAR_TEX_ROCK		'R'
+#define CHAR_TEX_SAND		'A'
+#define CHAR_TEX_GRAVEL		'L'
+#define CHAR_TEX_STUCCO		'Z'
+#define CHAR_TEX_BRICK		'B'
+#define CHAR_TEX_SNOW		'N'
+#define CHAR_TEX_HEAVYMETAL	'H'
+#define CHAR_TEX_LEAVES		'E'
+#define CHAR_TEX_SKY		'K'
+#define CHAR_TEX_GRASS		'P'
+*/
+
+
+#define WPN_SLOT_PRIMARY	0
+#define WPN_SLOT_SECONDARY	1
+#define WPN_SLOT_MELEE		2
+#define WPN_SLOT_GRENADES	3
+#define WPN_SLOT_BOMB		4
+
+#define SLEEVE_AXIS		0
+#define SLEEVE_ALLIES	1
+
+#define VM_BODYGROUP_GUN	0
+#define VM_BODYGROUP_SLEEVE	1
+
+#define PLAYER_SPEED_FROZEN				1
+#define PLAYER_SPEED_PRONE				50
+#define PLAYER_SPEED_PRONE_ZOOMED		30
+#define PLAYER_SPEED_PRONE_BAZOOKA_DEPLOYED		30
+#define PLAYER_SPEED_ZOOMED				42
+#define PLAYER_SPEED_BAZOOKA_DEPLOYED	50
+#define PLAYER_SPEED_NORMAL				600.0f
+
+#define PLAYER_SPEED_SLOWED				120
+#define PLAYER_SPEED_RUN				220
+#define PLAYER_SPEED_SPRINT				330
+
+#define PUSHAWAY_THINK_INTERVAL		(1.0f / 20.0f)
+
+#define VEC_PRONE_VIEW			Vector(0,0,10)
+#define VEC_PRONE_VIEW_SCALED( player )			( Vector(0,0,10) * player->GetModelScale() )
+
+#define TIME_TO_PRONE	1.2f	// should be 1.5!
+
+#define INITIAL_SPRINT_STAMINA_PENALTY 15
+#define LOW_STAMINA_THRESHOLD	35
+
+// changed to 80% of goldsrc values, gives the same end result
+#define ZOOM_SWAY_PRONE				0.1
+#define ZOOM_SWAY_DUCKING			0.2
+#define ZOOM_SWAY_STANDING			0.5
+#define ZOOM_SWAY_MOVING_PENALTY	0.4
+
+extern const char * s_WeaponAliasInfo[];
+
+enum
+{
+	//Dod hint messages					
+	HINT_FRIEND_SEEN = 0,				// #Hint_spotted_a_friend
+	HINT_ENEMY_SEEN,					// #Hint_spotted_an_enemy
+	HINT_FRIEND_INJURED,				// #Hint_try_not_to_injure_teammates
+	HINT_FRIEND_KILLED,					// #Hint_careful_around_teammates
+	HINT_ENEMY_KILLED,					// #Hint_killing_enemies_is_good
+	HINT_IN_AREA_CAP,					// #Hint_touched_area_capture
+	HINT_FLAG_TOUCH,					// #Hint_touched_control_point
+	HINT_OBJECT_PICKUP,					// #Hint_picked_up_object
+	HINT_MG_FIRE_UNDEPLOYED,			// #Hint_mgs_fire_better_deployed
+	HINT_SANDBAG_AREA,					// #Hint_sandbag_area_touch
+	HINT_BAZOOKA_PICKUP,				// #Hint_rocket_weapon_pickup
+	HINT_AMMO_EXHAUSTED,				// #Hint_out_of_ammo
+	HINT_PRONE,							// #Hint_prone
+	HINT_LOW_STAMINA,					// #Hint_low_stamina
+	HINT_OBJECT_REQUIRED,				// #Hint_area_requires_object	
+	HINT_PLAYER_KILLED_WAVETIME,		// #Hint_player_killed_wavetime 
+	HINT_WEAPON_OVERHEAT,				// #Hint_mg_overheat
+	HINT_SHOULDER_WEAPON,				// #game_shoulder_rpg
+
+	HINT_PICK_UP_WEAPON,				// #Hint_pick_up_weapon
+	HINT_PICK_UP_GRENADE,				// #Hint_pick_up_grenade
+	HINT_DEATHCAM,						// #Hint_death_cam
+	HINT_CLASSMENU,						// #Hint_class_menu
+
+	HINT_USE_MELEE,						// #Hint_use_2e_melee
+	HINT_USE_ZOOM,						// #Hint_use_zoom
+	HINT_USE_IRON_SIGHTS,				// #Hint_use_iron_sights
+	HINT_USE_SEMI_AUTO,					// #Hint_use_semi_auto
+	HINT_USE_SPRINT,					// #Hint_use_sprint
+	HINT_USE_DEPLOY,					// #Hint_use_deploy
+	HINT_USE_PRIME,						// #Hint_use_prime
+
+	HINT_MG_DEPLOY_USAGE,				// #Hint_mg_deploy_usage
+
+	HINT_MG_DEPLOY_TO_RELOAD,			// #Dod_mg_reload
+	HINT_GARAND_RELOAD,					// #Hint_garand_reload
+
+	HINT_TURN_OFF_HINTS,				// #Hint_turn_off_hints
+
+	HINT_NEED_BOMB,						// #Hint_need_bomb_to_plant
+	HINT_BOMB_PLANTED,					// #Hint_bomb_planted
+	HINT_DEFUSE_BOMB,					// #Hint_defuse_bomb
+	HINT_BOMB_TARGET,					// #Hint_bomb_target
+	HINT_BOMB_PICKUP,					// #Hint_bomb_pickup
+	HINT_BOMB_DEFUSE_ONGROUND,			// #Hint_bomb_defuse_onground
+
+	HINT_BOMB_PLANT_MAP,				// #Hint_bomb_plant_map
+	HINT_BOMB_FIRST_SELECT,				// #Hint_bomb_first_select
+
+	NUM_HINTS
+};
+
+extern const char *g_pszHintMessages[];
+
+// HINT_xxx bits to clear when the round restarts
+#define HINT_MASK_SPAWN_CLEAR ( 1 << HINT_FRIEND_KILLED )
+
+// criteria for when a weapon model wants to use an alt model
+#define ALTWPN_CRITERIA_NONE			0
+#define ALTWPN_CRITERIA_FIRING			(1 << 0)
+#define ALTWPN_CRITERIA_RELOADING		(1 << 1)
+#define ALTWPN_CRITERIA_DEPLOYED		(1 << 2)
+#define ALTWPN_CRITERIA_DEPLOYED_RELOAD	(1 << 3)
+#define ALTWPN_CRITERIA_PRONE			(1 << 4)	// player is prone
+#define ALTWPN_CRITERIA_PRONE_DEPLOYED_RELOAD (1 << 5)	// player should use special alt model when prone deployed reloading
+
+// eject brass shells
+#define EJECTBRASS_PISTOL		0
+#define EJECTBRASS_RIFLE		1
+#define EJECTBRASS_MG			2
+#define EJECTBRASS_MG_2			3	// ?
+#define EJECTBRASS_GARANDCLIP	4
+
+extern const char *pszTeamAlliesClasses[];
+extern const char *pszTeamAxisClasses[];
+
+enum
+{
+	DOD_COLLISIONGROUP_SHELLS = LAST_SHARED_COLLISION_GROUP,
+	DOD_COLLISIONGROUP_BLOCKERWALL,
+};
+
+enum
+{
+	PROGRESS_BAR_BANDAGER = 0,
+	PROGRESS_BAR_BANDAGEE,
+	PROGRESS_BAR_CAP,		// done by objective resource
+
+	NUM_PROGRESS_BAR_TYPES
+};
+
+// used for the corner cut panels in the HUD
+enum
+{
+	DOD_CORNERCUT_PANEL_BOTTOMRIGHT = 0,
+	DOD_CORNERCUT_PANEL_BOTTOMLEFT,
+	DOD_CORNERCUT_PANEL_TOPRIGHT,
+	DOD_CORNERCUT_PANEL_TOPLEFT,
+};
+
+enum ViewAnimationType {
+	VIEW_ANIM_LINEAR_Z_ONLY,
+	VIEW_ANIM_SPLINE_Z_ONLY,
+	VIEW_ANIM_EXPONENTIAL_Z_ONLY,
+};
+
+enum BombTargetState
+{
+	// invisible, not active
+	BOMB_TARGET_INACTIVE=0,
+
+	// visible, accepts planting +use
+	BOMB_TARGET_ACTIVE,
+
+	// visible, accepts disarm +use, counts down to explosion
+	// if disarmed, returns to BOMB_TARGET_ACTIVE
+	// if explodes, returns to BOMB_TARGET_INACTIVE
+	BOMB_TARGET_ARMED,
+
+	NUM_BOMB_TARGET_STATES
+};
+
+extern const char *pszWinPanelCategoryHeaders[];
+
+enum
+{
+	// Season 1
+	ACHIEVEMENT_DOD_THROW_BACK_GREN = 0,
+	ACHIEVEMENT_DOD_CONSECUTIVE_HEADSHOTS,
+	ACHIEVEMENT_DOD_MG_POSITION_STREAK,
+	ACHIEVEMENT_DOD_WIN_KNIFE_FIGHT,
+	ACHIEVEMENT_DOD_PLAY_CUSTOM_MAPS,
+	ACHIEVEMENT_DOD_KILLS_WITH_GRENADE,
+	ACHIEVEMENT_DOD_LONG_RANGE_ROCKET,
+	ACHIEVEMENT_DOD_END_ROUND_KILLS,
+	ACHIEVEMENT_DOD_CAP_LAST_FLAG,
+	ACHIEVEMENT_DOD_USE_ENEMY_WEAPONS,
+	ACHIEVEMENT_DOD_KILL_DOMINATING_MG,
+	ACHIEVEMENT_DOD_COLMAR_DEFENSE,
+	ACHIEVEMENT_DOD_BLOCK_CAPTURES,
+	ACHIEVEMENT_DOD_JAGD_OVERTIME_CAP,
+	ACHIEVEMENT_DOD_WEAPON_MASTERY,
+
+	// grinds
+	ACHIEVEMENT_DOD_KILLS_AS_ALLIES,
+	ACHIEVEMENT_DOD_KILLS_AS_AXIS,
+
+	ACHIEVEMENT_DOD_KILLS_AS_RIFLEMAN,
+	ACHIEVEMENT_DOD_KILLS_AS_ASSAULT,
+	ACHIEVEMENT_DOD_KILLS_AS_SUPPORT,
+	ACHIEVEMENT_DOD_KILLS_AS_SNIPER,
+	ACHIEVEMENT_DOD_KILLS_AS_MG,
+	ACHIEVEMENT_DOD_KILLS_AS_BAZOOKAGUY,
+
+	ACHIEVEMENT_DOD_KILLS_WITH_GARAND,
+	ACHIEVEMENT_DOD_KILLS_WITH_THOMPSON,
+	ACHIEVEMENT_DOD_KILLS_WITH_BAR,
+	ACHIEVEMENT_DOD_KILLS_WITH_SPRING,
+	ACHIEVEMENT_DOD_KILLS_WITH_30CAL,
+	ACHIEVEMENT_DOD_KILLS_WITH_BAZOOKA,
+	ACHIEVEMENT_DOD_KILLS_WITH_K98,
+	ACHIEVEMENT_DOD_KILLS_WITH_MP40, 
+	ACHIEVEMENT_DOD_KILLS_WITH_MP44, 
+	ACHIEVEMENT_DOD_KILLS_WITH_K98SCOPED,
+	ACHIEVEMENT_DOD_KILLS_WITH_MG42,
+	ACHIEVEMENT_DOD_KILLS_WITH_PSCHRECK,
+	ACHIEVEMENT_DOD_KILLS_WITH_COLT, 
+	ACHIEVEMENT_DOD_KILLS_WITH_P38,
+	ACHIEVEMENT_DOD_KILLS_WITH_C96,
+	ACHIEVEMENT_DOD_KILLS_WITH_M1CARBINE,
+	ACHIEVEMENT_DOD_KILLS_WITH_AMERKNIFE,
+	ACHIEVEMENT_DOD_KILLS_WITH_SPADE,
+	ACHIEVEMENT_DOD_KILLS_WITH_PUNCH,
+	ACHIEVEMENT_DOD_KILLS_WITH_FRAG_US,
+	ACHIEVEMENT_DOD_KILLS_WITH_FRAG_GER,
+	ACHIEVEMENT_DOD_KILLS_WITH_RIFLEGREN_US,
+	ACHIEVEMENT_DOD_KILLS_WITH_RIFLEGREN_GER,
+
+	ACHIEVEMENT_DOD_CAPTURE_GRIND,
+	ACHIEVEMENT_DOD_BLOCK_CAPTURES_GRIND,
+	ACHIEVEMENT_DOD_ROUNDS_WON_GRIND,
+
+	ACHIEVEMENT_DOD_BOMBS_PLANTED_GRIND,
+	ACHIEVEMENT_DOD_BOMBS_DEFUSED_GRIND,
+
+	ACHIEVEMENT_DOD_ALL_PACK_1,
+
+	ACHIEVEMENT_DOD_BEAT_THE_HEAT,
+
+	// Winter 2011
+	ACHIEVEMENT_DOD_COLLECT_HOLIDAY_GIFTS,
+
+	NUM_DOD_ACHIEVEMENTS
+};
+
+#define ACHIEVEMENT_NUM_CONSECUTIVE_HEADSHOTS 5
+#define ACHIEVEMENT_MG_STREAK_IS_DOMINATING	8
+#define ACHIEVEMENT_NUM_ENEMY_WPN_KILLS 5
+#define ACHIEVEMENT_LONG_RANGE_ROCKET_DIST	1200
+// other magic numbers exist inside the achievements themselves in achievements_dod.cpp
+
+enum
+{
+	DOD_MUZZLEFLASH_PISTOL = 0,
+	DOD_MUZZLEFLASH_AUTO,
+	DOD_MUZZLEFLASH_RIFLE,
+	DOD_MUZZLEFLASH_MG,
+	DOD_MUZZLEFLASH_ROCKET,
+	DOD_MUZZLEFLASH_MG42
+};
+
+#define DOD_KILLS_DOMINATION	4
+
+// Death notice flags
+#define DOD_DEATHFLAG_DOMINATION			0x0001	// killer is dominating victim
+#define DOD_DEATHFLAG_REVENGE				0x0002	// killer got revenge on victim
+
+enum
+{
+	ACHIEVEMENT_AWARDS_NONE = 0,
+	ACHIEVEMENT_AWARDS_RIFLEMAN,
+	ACHIEVEMENT_AWARDS_ASSAULT,	
+	ACHIEVEMENT_AWARDS_SUPPORT,		
+	ACHIEVEMENT_AWARDS_SNIPER,		
+	ACHIEVEMENT_AWARDS_MG,		
+	ACHIEVEMENT_AWARDS_ROCKET,
+	ACHIEVEMENT_AWARDS_ALL_PACK_1,
+
+	NUM_ACHIEVEMENT_AWARDS
+};
+
+extern const char *g_pszAchievementAwards[NUM_ACHIEVEMENT_AWARDS];
+extern const char *g_pszAchievementAwardMaterials_Allies[NUM_ACHIEVEMENT_AWARDS];
+extern const char *g_pszAchievementAwardMaterials_Axis[NUM_ACHIEVEMENT_AWARDS];
+
+enum DODStatType_t
+{
+	DODSTAT_PLAYTIME = 0,
+	DODSTAT_ROUNDSWON,
+	DODSTAT_ROUNDSLOST,
+	DODSTAT_KILLS,
+	DODSTAT_DEATHS,
+	DODSTAT_CAPTURES,
+	DODSTAT_BLOCKS,
+	DODSTAT_BOMBSPLANTED,
+	DODSTAT_BOMBSDEFUSED,
+	DODSTAT_DOMINATIONS,
+	DODSTAT_REVENGES,
+	DODSTAT_SHOTS_HIT,
+	DODSTAT_SHOTS_FIRED,
+	DODSTAT_HEADSHOTS,
+
+	DODSTAT_MAX
+};
+
+#define DODSTAT_FIRST	DODSTAT_PLAYTIME
+
+typedef struct 
+{
+	int m_iStat[DODSTAT_MAX];
+	bool m_bDirty[DODSTAT_MAX];
+
+} dod_stat_accumulator_t;
+
+#define NUM_DOD_PLAYERCLASSES	6
+
+#endif // DOD_SHAREDDEFS_H

game/shared/dod/dod_usermessages.cpp

@@ -0,0 +1,65 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "usermessages.h"
+#include "shake.h"
+#include "voice_gamemgr.h"
+
+// NVNT include to register in haptic user messages
+#include "haptics/haptic_msgs.h"
+
+void RegisterUserMessages()
+{
+	usermessages->Register( "Geiger", 1 );		// geiger info data
+	usermessages->Register( "Train", 1 );		// train control data
+	usermessages->Register( "HudText", -1 );	
+	usermessages->Register( "SayText", -1 );	
+	usermessages->Register( "TextMsg", -1 );
+	usermessages->Register( "ResetHUD", 1 );	// called every respawn
+	usermessages->Register( "GameTitle", 0 );	// show game title
+	usermessages->Register( "ItemPickup", -1 );	// for item history on screen
+	usermessages->Register( "ShowMenu", -1 );	// show hud menu
+	usermessages->Register( "Shake", 13 );		// shake view
+	usermessages->Register( "Fade", 10 );	// fade HUD in/out
+	usermessages->Register( "VGUIMenu", -1 );	// Show VGUI menu
+	usermessages->Register( "Rumble", 3 );	// Send a rumble to a controller
+	usermessages->Register( "CloseCaption", -1 ); // Show a caption (by string id number)(duration in 10th of a second)
+
+	usermessages->Register( "VoiceMask", VOICE_MAX_PLAYERS_DW*4 * 2 + 1 );
+	usermessages->Register( "RequestState", 0 );
+
+	usermessages->Register( "BarTime", -1 );	// For the C4 progress bar.
+	usermessages->Register( "Damage", -1 );		// for HUD damage indicators
+	usermessages->Register( "RadioText", -1 );		// for HUD damage indicators
+	usermessages->Register( "HintText", -1 );	// Displays hint text display
+	usermessages->Register( "KeyHintText", -1 );	// Displays hint text display
+	
+	usermessages->Register( "ReloadEffect", 2 );			// a player reloading..
+	usermessages->Register( "PlayerAnimEvent", -1 );	// jumping, firing, reload, etc.
+		
+	usermessages->Register( "HudMsg", -1 );
+
+	usermessages->Register( "VoiceSubtitle", 3 );
+	usermessages->Register( "HandSignalSubtitle", 2 );
+	usermessages->Register( "UpdateRadar", -1 );
+	usermessages->Register( "KillCam", -1 );
+	usermessages->Register( "DeathStats", 9 );
+
+	usermessages->Register( "AchievementEvent", -1 );
+	usermessages->Register( "DODPlayerStatsUpdate", -1 );
+
+	// Voting
+	usermessages->Register( "CallVoteFailed", -1 );
+	usermessages->Register( "VoteStart", -1 );
+	usermessages->Register( "VotePass", -1 );
+	usermessages->Register( "VoteFailed", 2 );
+	usermessages->Register( "VoteSetup", -1 );  // Initiates client-side voting UI
+
+	// NVNT register haptic user messages
+	RegisterHapticMessages();
+}
+

game/shared/dod/dod_viewmodel.cpp

@@ -0,0 +1,151 @@
+
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+//=============================================================================
+#include "cbase.h"
+#include "dod_viewmodel.h"
+
+#ifdef CLIENT_DLL
+#include "c_dod_player.h"
+#include "prediction.h"
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+LINK_ENTITY_TO_CLASS( dod_viewmodel, CDODViewModel );
+
+IMPLEMENT_NETWORKCLASS_ALIASED( DODViewModel, DT_DODViewModel )
+
+BEGIN_NETWORK_TABLE( CDODViewModel, DT_DODViewModel )
+END_NETWORK_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+#ifdef CLIENT_DLL
+CDODViewModel::CDODViewModel() : m_LagAnglesHistory("CDODViewModel::m_LagAnglesHistory")
+{
+	m_vLagAngles.Init();
+	m_LagAnglesHistory.Setup( &m_vLagAngles, 0 );
+	m_vLoweredWeaponOffset.Init();
+}
+#else
+CDODViewModel::CDODViewModel()
+{
+}
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CDODViewModel::~CDODViewModel()
+{
+}
+
+#ifdef CLIENT_DLL
+ConVar cl_wpn_sway_interp( "cl_wpn_sway_interp", "0.1", FCVAR_CLIENTDLL );
+ConVar cl_wpn_sway_scale( "cl_wpn_sway_scale", "2.6", FCVAR_CLIENTDLL );
+#endif
+
+void CDODViewModel::CalcViewModelLag( Vector& origin, QAngle& angles, QAngle& original_angles )
+{
+#ifdef CLIENT_DLL
+	if ( prediction->InPrediction() )
+	{
+		return;
+	}
+
+	float flSwayScale = cl_wpn_sway_scale.GetFloat();
+
+	CWeaponDODBase *pWeapon = dynamic_cast<CWeaponDODBase*>(GetWeapon());
+
+	if ( pWeapon )
+	{
+		flSwayScale *= pWeapon->GetViewModelSwayScale();
+	}
+
+	// Calculate our drift
+	Vector	forward, right, up;
+	AngleVectors( angles, &forward, &right, &up );
+
+	// Add an entry to the history.
+	m_vLagAngles = angles;
+	m_LagAnglesHistory.NoteChanged( gpGlobals->curtime, cl_wpn_sway_interp.GetFloat(), false );
+
+	// Interpolate back 100ms.
+	m_LagAnglesHistory.Interpolate( gpGlobals->curtime, cl_wpn_sway_interp.GetFloat() );
+
+	// Now take the 100ms angle difference and figure out how far the forward vector moved in local space.
+	Vector vLaggedForward;
+	QAngle angleDiff = m_vLagAngles - angles;
+	AngleVectors( -angleDiff, &vLaggedForward, 0, 0 );
+	Vector vForwardDiff = Vector(1,0,0) - vLaggedForward;
+
+	// Now offset the origin using that.
+	vForwardDiff *= flSwayScale;
+	origin += forward*vForwardDiff.x + right*-vForwardDiff.y + up*vForwardDiff.z;
+#endif
+}
+
+#ifdef CLIENT_DLL
+ConVar cl_gunlowerangle( "cl_gunlowerangle", "30", FCVAR_CLIENTDLL );
+ConVar cl_gunlowerspeed( "cl_gunlowerspeed", "2", FCVAR_CLIENTDLL );
+
+ConVar cl_test_vm_offset( "cl_test_vm_offset", "0 0 0", FCVAR_CHEAT | FCVAR_CLIENTDLL );
+#endif
+
+void CDODViewModel::CalcViewModelView( CBasePlayer *owner, const Vector& eyePosition, const QAngle& eyeAngles )
+{
+#if defined( CLIENT_DLL )
+
+	Vector vecNewOrigin = eyePosition;
+	QAngle vecNewAngles = eyeAngles;
+
+	// Check for lowering the weapon
+	C_DODPlayer *pPlayer = ToDODPlayer( owner );
+
+	Assert( pPlayer );
+
+	bool bLowered = pPlayer->IsWeaponLowered();
+
+	QAngle vecLoweredAngles(0,0,0);
+
+	m_vLoweredWeaponOffset.x = Approach( bLowered ? cl_gunlowerangle.GetFloat() : 0, m_vLoweredWeaponOffset.x, cl_gunlowerspeed.GetFloat() );
+	vecLoweredAngles.x += m_vLoweredWeaponOffset.x;
+
+	vecNewAngles += vecLoweredAngles;
+
+	Vector	forward, right, up;
+	AngleVectors( vecNewAngles, &forward, &right, &up );
+
+	Vector test;
+	const char *szTestOffset = cl_test_vm_offset.GetString();
+	sscanf( szTestOffset, " %f %f %f", &test[0], &test[1], &test[2] );
+
+	// cvar cl_test_vm_offset overrides calculated view model offset
+	if ( test.Length() > 0 )
+	{
+		vecNewOrigin += forward * test[0] + right * test[1] + up * test[2];
+	}
+	else
+	{
+		// Move the view model origin between the script standing and prone position
+		// based on the current view height
+		CWeaponDODBase *pWeapon = dynamic_cast<CWeaponDODBase*>(GetWeapon());
+
+		if ( pWeapon )
+		{
+			Vector offset = pWeapon->GetDesiredViewModelOffset( pPlayer );
+
+			// add our offset in the proper direction
+			vecNewOrigin += forward * offset[0] + right * offset[1] + up * offset[2];
+		}
+	}
+
+	BaseClass::CalcViewModelView( owner, vecNewOrigin, vecNewAngles );
+
+#endif
+}

game/shared/dod/dod_viewmodel.h

@@ -0,0 +1,60 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+#ifndef DOD_VIEWMODEL_H
+#define DOD_VIEWMODEL_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "predictable_entity.h"
+#include "utlvector.h"
+#include "baseplayer_shared.h"
+#include "shared_classnames.h"
+
+#if defined( CLIENT_DLL )
+#define CDODViewModel C_DODViewModel
+#endif
+
+class CDODViewModel : public CBaseViewModel
+{
+	DECLARE_CLASS( CDODViewModel, CBaseViewModel );
+public:
+
+	DECLARE_NETWORKCLASS();
+
+	CDODViewModel( void );
+	~CDODViewModel( void );
+
+	virtual void CalcViewModelLag( Vector& origin, QAngle& angles, QAngle& original_angles );
+	virtual void CalcViewModelView( CBasePlayer *owner, const Vector& eyePosition, const QAngle& eyeAngles );
+
+#if defined( CLIENT_DLL )
+	virtual bool ShouldPredict( void )
+	{
+		if ( GetOwner() && GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+#endif
+
+private:
+
+#if defined( CLIENT_DLL )
+
+	// This is used to lag the angles.
+	CInterpolatedVar<QAngle> m_LagAnglesHistory;
+	QAngle m_vLagAngles;
+
+	CDODViewModel( const CDODViewModel & ); // not defined, not accessible
+
+	QAngle m_vLoweredWeaponOffset;
+#endif
+};
+
+#endif // DOD_VIEWMODEL_H

game/shared/dod/dod_weapon_parse.cpp

@@ -0,0 +1,195 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include <KeyValues.h>
+#include "dod_weapon_parse.h"
+#include "dod_shareddefs.h"
+
+// criteria that we parse out of the file.
+// tells us which player animation states
+// should use the alternate wpn p model
+static struct
+{
+	const char *m_pCriteriaName;
+	int m_iFlagValue;
+} g_AltWpnCritera[] =
+{
+	{ "ALTWPN_CRITERIA_FIRING",		ALTWPN_CRITERIA_FIRING },
+	{ "ALTWPN_CRITERIA_RELOADING",	ALTWPN_CRITERIA_RELOADING },
+	{ "ALTWPN_CRITERIA_DEPLOYED",	ALTWPN_CRITERIA_DEPLOYED },
+	{ "ALTWPN_CRITERIA_DEPLOYED_RELOAD", ALTWPN_CRITERIA_DEPLOYED_RELOAD },
+	{ "ALTWPN_CRITERIA_PRONE_DEPLOYED_RELOAD", ALTWPN_CRITERIA_PRONE_DEPLOYED_RELOAD }
+};
+
+FileWeaponInfo_t* CreateWeaponInfo()
+{
+	return new CDODWeaponInfo;
+}
+
+
+CDODWeaponInfo::CDODWeaponInfo()
+{
+	m_szReloadModel[0] = '\0';
+	m_szDeployedModel[0] = '\0';
+	m_szDeployedReloadModel[0] = '\0';
+	m_szProneDeployedReloadModel[0] = '\0';
+}
+
+
+void CDODWeaponInfo::Parse( KeyValues *pKeyValuesData, const char *szWeaponName )
+{
+	BaseClass::Parse( pKeyValuesData, szWeaponName );
+
+	m_iCrosshairMinDistance		= pKeyValuesData->GetInt( "CrosshairMinDistance", 4 );
+	m_iCrosshairDeltaDistance	= pKeyValuesData->GetInt( "CrosshairDeltaDistance", 3 );
+	m_iMuzzleFlashType			= pKeyValuesData->GetFloat( "MuzzleFlashType", 0 );
+	m_flMuzzleFlashScale		= pKeyValuesData->GetFloat( "MuzzleFlashScale", 0.5 );
+
+	m_iDamage				= pKeyValuesData->GetInt( "Damage", 1 );
+	m_flAccuracy			= pKeyValuesData->GetFloat( "Accuracy", 1.0 );
+	m_flSecondaryAccuracy	= pKeyValuesData->GetFloat( "SecondaryAccuracy", 1.0 );
+	m_flAccuracyMovePenalty = pKeyValuesData->GetFloat( "AccuracyMovePenalty", 0.1 );
+	m_flRecoil				= pKeyValuesData->GetFloat( "Recoil", 99.0 );
+	m_flPenetration			= pKeyValuesData->GetFloat( "Penetration", 1.0 );
+	m_flFireDelay			= pKeyValuesData->GetFloat( "FireDelay", 0.1 );
+	m_flSecondaryFireDelay	= pKeyValuesData->GetFloat( "SecondaryFireDelay", 0.1 );
+	m_flTimeToIdleAfterFire = pKeyValuesData->GetFloat( "IdleTimeAfterFire", 1.0 );
+	m_flIdleInterval		= pKeyValuesData->GetFloat( "IdleInterval", 1.0 );
+	m_bCanDrop				= ( pKeyValuesData->GetInt( "CanDrop", 1 ) > 0 );
+	m_iBulletsPerShot		= pKeyValuesData->GetInt( "BulletsPerShot", 1 );
+	
+	m_iHudClipHeight		= pKeyValuesData->GetInt( "HudClipHeight", 0 );
+	m_iHudClipBaseHeight	= pKeyValuesData->GetInt( "HudClipBaseHeight", 0 );
+	m_iHudClipBulletHeight	= pKeyValuesData->GetInt( "HudClipBulletHeight", 0 );
+
+	m_iAmmoPickupClips		= pKeyValuesData->GetInt( "AmmoPickupClips", 2 );
+	
+	m_iDefaultAmmoClips		= pKeyValuesData->GetInt( "DefaultAmmoClips", 0 );
+
+	m_flViewModelFOV		= pKeyValuesData->GetFloat( "ViewModelFOV", 90.0f );
+
+//	const char *pAnimEx = pKeyValuesData->GetString( "PlayerAnimationExtension", "error" );
+//	Q_strncpy( m_szAnimExtension, pAnimEx, sizeof( m_szAnimExtension ) );
+
+	// if this key exists, use this for reload animations instead of anim_prefix
+//	Q_strncpy( m_szReloadAnimPrefix, pKeyValuesData->GetString( "reload_anim_prefix", "" ), MAX_WEAPON_PREFIX );
+
+	m_flBotAudibleRange = pKeyValuesData->GetFloat( "BotAudibleRange", 2000.0f );
+	
+	m_iTracerType = pKeyValuesData->GetInt( "Tracer", 0 );
+
+	//Weapon Type
+	const char *pTypeString = pKeyValuesData->GetString( "WeaponType", NULL );
+	
+	m_WeaponType = WPN_TYPE_UNKNOWN;
+	if ( !pTypeString )
+	{
+		Assert( false );
+	}
+	else if ( Q_stricmp( pTypeString, "Melee" ) == 0 )
+	{
+		m_WeaponType = WPN_TYPE_MELEE;
+	}
+	else if ( Q_stricmp( pTypeString, "Camera" ) == 0 )
+	{
+		m_WeaponType = WPN_TYPE_CAMERA;
+	}
+	else if ( Q_stricmp( pTypeString, "Grenade" ) == 0 )
+	{
+		m_WeaponType = WPN_TYPE_GRENADE;
+	}
+	else if ( Q_stricmp( pTypeString, "Pistol" ) == 0 )
+	{
+		m_WeaponType = WPN_TYPE_PISTOL;
+	}
+	else if ( Q_stricmp( pTypeString, "Rifle" ) == 0 )
+	{
+		m_WeaponType = WPN_TYPE_RIFLE;
+	}
+	else if ( Q_stricmp( pTypeString, "Sniper" ) == 0 )
+	{
+		m_WeaponType = WPN_TYPE_SNIPER;
+	}
+	else if ( Q_stricmp( pTypeString, "SubMG" ) == 0 )
+	{
+		m_WeaponType = WPN_TYPE_SUBMG;
+	}
+	else if ( Q_stricmp( pTypeString, "MG" ) == 0 )
+	{
+		m_WeaponType = WPN_TYPE_MG;
+	}
+	else if ( Q_stricmp( pTypeString, "Bazooka" ) == 0 )
+	{
+		m_WeaponType = WPN_TYPE_BAZOOKA;
+	}
+	else if ( Q_stricmp( pTypeString, "Bandage" ) == 0 )
+	{
+		m_WeaponType = WPN_TYPE_BANDAGE;
+	}
+	else if ( Q_stricmp( pTypeString, "Sidearm" ) == 0 )
+	{
+		m_WeaponType = WPN_TYPE_SIDEARM;
+	}
+	else if ( Q_stricmp( pTypeString, "RifleGrenade" ) == 0 )
+	{
+		m_WeaponType = WPN_TYPE_RIFLEGRENADE;
+	}
+	else if ( Q_stricmp( pTypeString, "Bomb" ) == 0 )
+	{
+		m_WeaponType = WPN_TYPE_BOMB;
+	}
+	else
+	{
+		Assert( false );
+	}
+
+	Q_strncpy( m_szReloadModel, pKeyValuesData->GetString( "reloadmodel" ), sizeof( m_szReloadModel ) );
+	Q_strncpy( m_szDeployedModel, pKeyValuesData->GetString( "deployedmodel" ), sizeof( m_szDeployedModel ) );
+	Q_strncpy( m_szDeployedReloadModel, pKeyValuesData->GetString( "deployedreloadmodel" ), sizeof( m_szDeployedReloadModel ) );
+	Q_strncpy( m_szProneDeployedReloadModel, pKeyValuesData->GetString( "pronedeployedreloadmodel" ), sizeof( m_szProneDeployedReloadModel ) );
+
+
+	m_iAltWpnCriteria = ALTWPN_CRITERIA_NONE;
+
+	for ( int i=0; i < ARRAYSIZE( g_AltWpnCritera ); i++ )
+	{
+		int iVal = pKeyValuesData->GetInt( g_AltWpnCritera[i].m_pCriteriaName, 0 );
+		if ( iVal == 1 )
+		{
+			m_iAltWpnCriteria |= g_AltWpnCritera[i].m_iFlagValue;
+		}
+	}
+
+	const char *szNormalOffset = pKeyValuesData->GetString( "vm_normal_offset", "0 0 0" );
+	const char *szProneOffset = pKeyValuesData->GetString( "vm_prone_offset", "0 0 0" );
+	const char *szIronSightOffset = pKeyValuesData->GetString( "vm_ironsight_offset", "0 0 0" );
+
+	sscanf( szNormalOffset, "%f %f %f", &m_vecViewNormalOffset[0], &m_vecViewNormalOffset[1], &m_vecViewNormalOffset[2]);
+	sscanf( szProneOffset, "%f %f %f", &m_vecViewProneOffset[0], &m_vecViewProneOffset[1], &m_vecViewProneOffset[2]);
+	sscanf( szIronSightOffset, "%f %f %f", &m_vecIronSightOffset[0], &m_vecIronSightOffset[1], &m_vecIronSightOffset[2]);
+
+	m_iDefaultTeam = TEAM_ALLIES;
+
+	const char *pDefaultTeam = pKeyValuesData->GetString( "default_team", NULL );
+
+	if ( pDefaultTeam )
+	{
+		if ( FStrEq( pDefaultTeam, "Axis" ) )
+		{
+			m_iDefaultTeam = TEAM_AXIS;
+		}
+		else if ( FStrEq( pDefaultTeam, "Allies" ) )
+		{
+			m_iDefaultTeam = TEAM_ALLIES;
+		}
+		else
+		{
+			Assert( !"invalid param to \"default_team\" in weapon scripts\n" );
+		}
+	}
+}
+

game/shared/dod/dod_weapon_parse.h

@@ -0,0 +1,103 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef DOD_WEAPON_PARSE_H
+#define DOD_WEAPON_PARSE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "weapon_parse.h"
+#include "networkvar.h"
+
+#define WPN_TYPE_MELEE			(1<<0)
+#define WPN_TYPE_GRENADE		(1<<1)			
+//#define WPN_TYPE_GRENADE_LIVE	(1<<2)	//exploding grenades, unused
+#define WPN_TYPE_PISTOL			(1<<3)			
+#define WPN_TYPE_RIFLE			(1<<4)			
+#define WPN_TYPE_SNIPER			(1<<5)		
+#define WPN_TYPE_SUBMG			(1<<6)			
+#define WPN_TYPE_MG				(1<<7)	//mg42, 30cal
+#define WPN_TYPE_BAZOOKA		(1<<8)
+#define WPN_TYPE_BANDAGE		(1<<9)
+#define WPN_TYPE_SIDEARM		(1<<10)	//carbine - secondary weapons
+#define WPN_TYPE_RIFLEGRENADE	(1<<11)
+#define WPN_TYPE_BOMB			(1<<12)
+#define WPN_TYPE_UNKNOWN		(1<<13)
+#define WPN_TYPE_CAMERA			(1<<12)
+
+#define WPN_MASK_GUN	( WPN_TYPE_PISTOL | WPN_TYPE_RIFLE | WPN_TYPE_SNIPER | WPN_TYPE_SUBMG | WPN_TYPE_MG | WPN_TYPE_SIDEARM )
+
+//--------------------------------------------------------------------------------------------------------
+class CDODWeaponInfo : public FileWeaponInfo_t
+{
+public:
+	DECLARE_CLASS_GAMEROOT( CDODWeaponInfo, FileWeaponInfo_t );
+	
+	CDODWeaponInfo();
+	
+	virtual void Parse( ::KeyValues *pKeyValuesData, const char *szWeaponName );
+
+	int		m_iDamage;
+	int		m_flPenetration;
+	int		m_iBulletsPerShot;
+	int		m_iMuzzleFlashType;
+	float   m_flMuzzleFlashScale;
+
+	bool	m_bCanDrop;
+
+	float	m_flRecoil;
+
+	float	m_flRange;
+	float	m_flRangeModifier;
+
+	float	m_flAccuracy;
+	float	m_flSecondaryAccuracy;
+	float	m_flAccuracyMovePenalty;
+
+	float	m_flFireDelay;
+	float	m_flSecondaryFireDelay;
+
+	int		m_iCrosshairMinDistance;
+	int		m_iCrosshairDeltaDistance;
+
+	int		m_WeaponType;
+
+	float	m_flBotAudibleRange;
+
+	char	m_szReloadModel[MAX_WEAPON_STRING];
+	char	m_szDeployedModel[MAX_WEAPON_STRING];
+	char	m_szDeployedReloadModel[MAX_WEAPON_STRING];
+	char	m_szProneDeployedReloadModel[MAX_WEAPON_STRING];
+
+	//timers
+	float	m_flTimeToIdleAfterFire;	//wait this long until idling after fire
+	float	m_flIdleInterval;			//wait this long after idling to idle again
+
+	//ammo
+	int		m_iDefaultAmmoClips;
+	int		m_iAmmoPickupClips;
+
+	int		m_iHudClipHeight;
+	int		m_iHudClipBaseHeight;
+	int		m_iHudClipBulletHeight;
+
+	int		m_iTracerType;
+
+	float	m_flViewModelFOV;
+
+	int		m_iAltWpnCriteria;
+
+	Vector	m_vecViewNormalOffset;
+	Vector	m_vecViewProneOffset;
+	Vector  m_vecIronSightOffset;
+
+	int		m_iDefaultTeam;
+};
+
+
+#endif // DOD_WEAPON_PARSE_H

game/shared/dod/fx_dod_shared.cpp

@@ -0,0 +1,370 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "fx_dod_shared.h"
+#include "weapon_dodbase.h"
+#include "engine/ivdebugoverlay.h"
+
+#ifndef CLIENT_DLL
+	#include "ilagcompensationmanager.h"
+#endif
+
+#ifndef CLIENT_DLL
+
+//=============================================================================
+//
+// Explosions.
+//
+class CTEDODExplosion : public CBaseTempEntity
+{
+public:
+
+	DECLARE_CLASS( CTEDODExplosion, CBaseTempEntity );
+	DECLARE_SERVERCLASS();
+
+	CTEDODExplosion( const char *name );
+
+public:
+
+	Vector m_vecOrigin;
+	Vector m_vecNormal;
+};
+
+// Singleton to fire explosion objects
+static CTEDODExplosion g_TEDODExplosion( "DODExplosion" );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *name - 
+//-----------------------------------------------------------------------------
+CTEDODExplosion::CTEDODExplosion( const char *name ) : CBaseTempEntity( name )
+{
+	m_vecOrigin.Init();
+	m_vecNormal.Init();
+}
+
+IMPLEMENT_SERVERCLASS_ST( CTEDODExplosion, DT_TEDODExplosion )
+	SendPropFloat( SENDINFO_NOCHECK( m_vecOrigin[0] ), -1, SPROP_COORD_MP_INTEGRAL ),
+	SendPropFloat( SENDINFO_NOCHECK( m_vecOrigin[1] ), -1, SPROP_COORD_MP_INTEGRAL ),
+	SendPropFloat( SENDINFO_NOCHECK( m_vecOrigin[2] ), -1, SPROP_COORD_MP_INTEGRAL ),
+	SendPropVector( SENDINFO_NOCHECK( m_vecNormal ), 6, 0, -1.0f, 1.0f ),
+END_SEND_TABLE()
+
+void TE_DODExplosion( IRecipientFilter &filter, float flDelay, const Vector &vecOrigin, const Vector &vecNormal )
+{
+	VectorCopy( vecOrigin, g_TEDODExplosion.m_vecOrigin );
+	VectorCopy( vecNormal, g_TEDODExplosion.m_vecNormal );
+
+	// Send it over the wire
+	g_TEDODExplosion.Create( filter, flDelay );
+}
+
+#endif
+
+#ifdef CLIENT_DLL
+
+	#include "fx_impact.h"
+
+	extern void FX_TracerSound( const Vector &start, const Vector &end, int iTracerType );
+
+	// this is a cheap ripoff from CBaseCombatWeapon::WeaponSound():
+	void FX_WeaponSound(
+		int iPlayerIndex,
+		WeaponSound_t sound_type,
+		const Vector &vOrigin,
+		CDODWeaponInfo *pWeaponInfo )
+	{
+
+		// If we have some sounds from the weapon classname.txt file, play a random one of them
+		const char *shootsound = pWeaponInfo->aShootSounds[ sound_type ]; 
+		if ( !shootsound || !shootsound[0] )
+			return;
+
+		CBroadcastRecipientFilter filter; // this is client side only
+
+		if ( !te->CanPredict() )
+			return;
+				
+		CBaseEntity::EmitSound( filter, iPlayerIndex, shootsound, &vOrigin ); 
+	}
+
+	class CGroupedSound
+	{
+	public:
+		string_t m_SoundName;
+		Vector m_vPos;
+	};
+
+	CUtlVector<CGroupedSound> g_GroupedSounds;
+
+	
+	// Called by the ImpactSound function.
+	void ShotgunImpactSoundGroup( const char *pSoundName, const Vector &vEndPos )
+	{
+		// Don't play the sound if it's too close to another impact sound.
+		for ( int i=0; i < g_GroupedSounds.Count(); i++ )
+		{
+			CGroupedSound *pSound = &g_GroupedSounds[i];
+
+			if ( vEndPos.DistToSqr( pSound->m_vPos ) < 300*300 )
+			{
+				if ( Q_stricmp( pSound->m_SoundName, pSoundName ) == 0 )
+					return;
+			}
+		}
+
+		// Ok, play the sound and add it to the list.
+		CLocalPlayerFilter filter;
+		C_BaseEntity::EmitSound( filter, NULL, pSoundName, &vEndPos );
+
+		int tail = g_GroupedSounds.AddToTail();
+		g_GroupedSounds[tail].m_SoundName = pSoundName;
+		g_GroupedSounds[tail].m_vPos = vEndPos;
+	}
+
+
+	void StartGroupingSounds()
+	{
+		Assert( g_GroupedSounds.Count() == 0 );
+		SetImpactSoundRoute( ShotgunImpactSoundGroup );
+	}
+
+
+	void EndGroupingSounds()
+	{
+		g_GroupedSounds.Purge();
+		SetImpactSoundRoute( NULL );
+	}
+
+#else
+
+	#include "te_firebullets.h"
+
+	// Server doesn't play sounds anyway.
+	void StartGroupingSounds() {}
+	void EndGroupingSounds() {}
+	void FX_WeaponSound ( int iPlayerIndex,
+		WeaponSound_t sound_type,
+		const Vector &vOrigin,
+		CDODWeaponInfo *pWeaponInfo ) {};
+
+#endif
+
+
+
+// This runs on both the client and the server.
+// On the server, it only does the damage calculations.
+// On the client, it does all the effects.
+void FX_FireBullets( 
+	int	iPlayerIndex,
+	const Vector &vOrigin,
+	const QAngle &vAngles,
+	int	iWeaponID,
+	int	iMode,
+	int iSeed,
+	float flSpread
+	)
+{
+	bool bDoEffects = true;
+
+#ifdef CLIENT_DLL
+	C_DODPlayer *pPlayer = ToDODPlayer( ClientEntityList().GetBaseEntity( iPlayerIndex ) );
+#else
+	CDODPlayer *pPlayer = ToDODPlayer( UTIL_PlayerByIndex( iPlayerIndex) );
+#endif
+
+	const char * weaponAlias =	WeaponIDToAlias( iWeaponID );
+
+	if ( !weaponAlias )
+	{
+		DevMsg("FX_FireBullets: weapon alias for ID %i not found\n", iWeaponID );
+		return;
+	}
+
+	//MATTTODO: Why are we looking up the weapon info again when every weapon
+	// stores its own m_pWeaponInfo pointer?
+
+	char wpnName[128];
+	Q_snprintf( wpnName, sizeof( wpnName ), "weapon_%s", weaponAlias );
+	WEAPON_FILE_INFO_HANDLE	hWpnInfo = LookupWeaponInfoSlot( wpnName );
+
+	if ( hWpnInfo == GetInvalidWeaponInfoHandle() )
+	{
+		DevMsg("FX_FireBullets: LookupWeaponInfoSlot failed for weapon %s\n", wpnName );
+		return;
+	}
+
+	CDODWeaponInfo *pWeaponInfo = static_cast< CDODWeaponInfo* >( GetFileWeaponInfoFromHandle( hWpnInfo ) );
+
+#ifdef CLIENT_DLL
+	if( pPlayer && !pPlayer->IsDormant() )
+		pPlayer->DoAnimationEvent( PLAYERANIMEVENT_FIRE_GUN );
+#else
+	if( pPlayer )
+		pPlayer->DoAnimationEvent( PLAYERANIMEVENT_FIRE_GUN );
+#endif	
+
+#ifndef CLIENT_DLL
+	// if this is server code, send the effect over to client as temp entity
+	// Dispatch one message for all the bullet impacts and sounds.
+	TE_FireBullets( 
+		iPlayerIndex,
+		vOrigin, 
+		vAngles, 
+		iWeaponID,
+		iMode,
+		iSeed,
+		flSpread
+	);
+
+	bDoEffects = false; // no effects on server
+
+	// Let the player remember the usercmd he fired a weapon on. Assists in making decisions about lag compensation.
+	pPlayer->NoteWeaponFired();
+#endif
+
+	
+
+	WeaponSound_t sound_type = SINGLE;
+
+	if ( bDoEffects)
+	{
+		FX_WeaponSound( iPlayerIndex, sound_type, vOrigin, pWeaponInfo );
+	}
+
+	// Fire bullets, calculate impacts & effects
+	if ( !pPlayer )
+		return;
+	
+	StartGroupingSounds();
+
+#if !defined (CLIENT_DLL)
+	// Move other players back to history positions based on local player's lag
+	lagcompensation->StartLagCompensation( pPlayer, pPlayer->GetCurrentCommand() );
+#endif
+
+	RandomSeed( iSeed );
+
+	float x, y;
+	do
+	{
+		x = random->RandomFloat( -0.5, 0.5 ) + random->RandomFloat( -0.5, 0.5 );
+		y = random->RandomFloat( -0.5, 0.5 ) + random->RandomFloat( -0.5, 0.5 );
+	} while ( (x * x + y * y) > 1.0f );
+
+	Vector vecForward, vecRight, vecUp;
+	AngleVectors( vAngles, &vecForward, &vecRight, &vecUp );
+
+	Vector vecDirShooting = vecForward +
+					x * flSpread * vecRight +
+					y * flSpread * vecUp;
+
+	vecDirShooting.NormalizeInPlace();
+
+	FireBulletsInfo_t info( 1 /*shots*/, vOrigin, vecDirShooting, Vector( flSpread, flSpread, FLOAT32_NAN), MAX_COORD_RANGE, pWeaponInfo->iAmmoType );
+	info.m_flDamage = pWeaponInfo->m_iDamage;
+	info.m_pAttacker = pPlayer;
+
+	pPlayer->FireBullets( info );
+
+#ifdef CLIENT_DLL
+	
+	{
+		trace_t tr;		
+		UTIL_TraceLine( vOrigin, vOrigin + vecDirShooting * MAX_COORD_RANGE, MASK_SOLID, pPlayer, COLLISION_GROUP_NONE, &tr );
+
+		// if this is a local player, start at attachment on view model
+		// else start on attachment on weapon model
+
+		int iEntIndex = pPlayer->entindex();
+		int iAttachment = 1;
+
+		Vector vecStart = tr.startpos; 
+		QAngle angAttachment;
+
+		C_DODPlayer *pLocalPlayer = C_DODPlayer::GetLocalDODPlayer();
+
+		bool bInToolRecordingMode = clienttools->IsInRecordingMode();
+
+		// try to align tracers to actual weapon barrel if possible
+		if ( pPlayer->IsLocalPlayer() && !bInToolRecordingMode )
+		{
+			C_BaseViewModel *pViewModel = pPlayer->GetViewModel(0);
+
+			if ( pViewModel )
+			{
+				iEntIndex = pViewModel->entindex();
+				pViewModel->GetAttachment( iAttachment, vecStart, angAttachment );
+			}
+		}
+		else if ( pLocalPlayer &&
+					pLocalPlayer->GetObserverTarget() == pPlayer &&
+					pLocalPlayer->GetObserverMode() == OBS_MODE_IN_EYE )
+		{	
+			// get our observer target's view model
+
+			C_BaseViewModel *pViewModel = pLocalPlayer->GetViewModel(0);
+
+			if ( pViewModel )
+			{
+				iEntIndex = pViewModel->entindex();
+				pViewModel->GetAttachment( iAttachment, vecStart, angAttachment );
+			}
+		}
+		else if ( !pPlayer->IsDormant() )
+		{
+			// fill in with third person weapon model index
+			C_BaseCombatWeapon *pWeapon = pPlayer->GetActiveWeapon();
+
+			if( pWeapon )
+			{
+            	iEntIndex = pWeapon->entindex();
+
+				int nModelIndex = pWeapon->GetModelIndex();
+				int nWorldModelIndex = pWeapon->GetWorldModelIndex();
+				if ( bInToolRecordingMode && nModelIndex != nWorldModelIndex )
+				{
+					pWeapon->SetModelIndex( nWorldModelIndex );
+				}
+
+				pWeapon->GetAttachment( iAttachment, vecStart, angAttachment );
+
+				if ( bInToolRecordingMode && nModelIndex != nWorldModelIndex )
+				{
+					pWeapon->SetModelIndex( nModelIndex );
+				}
+			}
+		}
+
+		switch( pWeaponInfo->m_iTracerType )
+		{
+		case 1:		// Machine gun, heavy tracer
+			UTIL_Tracer( vecStart, tr.endpos, iEntIndex, TRACER_DONT_USE_ATTACHMENT, 5000.0, true, "BrightTracer" );
+			break;
+
+		case 2:		// rifle, smg, light tracer
+			vecStart += vecDirShooting * 150;
+			UTIL_Tracer( vecStart, tr.endpos, iEntIndex, TRACER_DONT_USE_ATTACHMENT, 5000.0, true, "FaintTracer" );
+			break;
+
+		case 0:	// pistols etc, just do the sound
+			{
+				FX_TracerSound( vecStart, tr.endpos, TRACER_TYPE_DEFAULT );
+			}
+		default:
+			break;
+		}
+	}
+#endif
+
+#if !defined (CLIENT_DLL)
+	lagcompensation->FinishLagCompensation( pPlayer );
+#endif
+
+	EndGroupingSounds();
+}
+

game/shared/dod/fx_dod_shared.h

@@ -0,0 +1,44 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef FX_DOD_SHARED_H
+#define FX_DOD_SHARED_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#ifdef CLIENT_DLL
+	#include "c_dod_player.h"
+#else
+	#include "dod_player.h"
+#endif
+
+#include "dod_weapon_parse.h"
+
+
+// This runs on both the client and the server.
+// On the server, it only does the damage calculations.
+// On the client, it does all the effects.
+void FX_FireBullets( 
+	int	iPlayer,
+	const Vector &vOrigin,
+	const QAngle &vAngles,
+	int	iWeaponID,
+	int	iMode,
+	int iSeed,
+	float flSpread
+	);
+
+
+#ifndef CLIENT_DLL
+
+	void TE_DODExplosion( IRecipientFilter &filter, float flDelay, const Vector &vecOrigin, const Vector &vecNormal );
+
+#endif
+
+
+#endif // FX_DOD_SHARED_H

game/shared/dod/weapon_30cal.cpp

@@ -0,0 +1,423 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodbipodgun.h"
+
+#if defined( CLIENT_DLL )
+
+	#include "c_dod_player.h"
+
+	#define CWeapon30cal C_Weapon30cal
+
+#else
+
+	#include "dod_player.h"
+
+#endif
+
+
+class CWeapon30cal : public CDODBipodWeapon
+{
+public:
+	DECLARE_CLASS( CWeapon30cal, CDODBipodWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+	
+	CWeapon30cal()  {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_30CAL; }
+
+	// weapon id for stats purposes
+	virtual DODWeaponID GetStatsWeaponID( void )
+	{
+		if ( !IsDeployed() )
+			return WEAPON_30CAL_UNDEPLOYED;
+		else 
+			return WEAPON_30CAL;
+	}
+
+	virtual void PrimaryAttack( void );
+
+	virtual bool ShouldDrawCrosshair( void ) { return IsDeployed(); }
+
+	virtual bool Reload( void );
+
+	virtual Activity GetDrawActivity( void );
+	virtual Activity GetDeployActivity( void );
+	virtual Activity GetUndeployActivity( void );
+	virtual Activity GetIdleActivity( void );
+	virtual Activity GetPrimaryAttackActivity( void );
+
+	virtual float GetRecoil( void );
+
+private:
+	CWeapon30cal( const CWeapon30cal & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( Weapon30cal, DT_Weapon30cal )
+
+BEGIN_NETWORK_TABLE( CWeapon30cal, DT_Weapon30cal )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeapon30cal )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_30cal, CWeapon30cal );
+PRECACHE_WEAPON_REGISTER( weapon_30cal );
+
+acttable_t CWeapon30cal::m_acttable[] = 
+{
+	{ ACT_DOD_STAND_AIM,					ACT_DOD_STAND_AIM_30CAL,				false },
+	{ ACT_DOD_CROUCH_AIM,					ACT_DOD_CROUCH_AIM_30CAL,				false },
+	{ ACT_DOD_CROUCHWALK_AIM,				ACT_DOD_CROUCHWALK_AIM_30CAL,			false },
+	{ ACT_DOD_WALK_AIM,						ACT_DOD_WALK_AIM_30CAL,					false },
+	{ ACT_DOD_RUN_AIM,						ACT_DOD_RUN_AIM_30CAL,					false },
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_30CAL,				false },
+	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_IDLE_30CAL,			false },
+	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_IDLE_30CAL,				false },
+	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_IDLE_30CAL,				false },
+	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_IDLE_30CAL,			false },
+	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_IDLE_30CAL,				false },
+	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_IDLE_30CAL,					false },
+	{ ACT_SPRINT,							ACT_DOD_SPRINT_IDLE_30CAL,				false },
+
+	{ ACT_RANGE_ATTACK1,					ACT_DOD_PRIMARYATTACK_30CAL,			false },
+	{ ACT_DOD_PRIMARYATTACK_CROUCH,			ACT_DOD_PRIMARYATTACK_30CAL,			false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE,			ACT_DOD_PRIMARYATTACK_PRONE_30CAL,		false },
+	{ ACT_DOD_DEPLOYED,						ACT_DOD_DEPLOY_30CAL,					false },
+	{ ACT_DOD_PRONE_DEPLOYED,				ACT_DOD_PRONE_DEPLOY_30CAL,				false },
+	{ ACT_DOD_PRIMARYATTACK_DEPLOYED,		ACT_DOD_PRIMARYATTACK_DEPLOYED_30CAL,	false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE_DEPLOYED,	ACT_DOD_PRIMARYATTACK_PRONE_DEPLOYED_30CAL,false },
+	{ ACT_DOD_RELOAD_DEPLOYED,				ACT_DOD_RELOAD_DEPLOYED_30CAL,			false },
+	{ ACT_DOD_RELOAD_PRONE_DEPLOYED,		ACT_DOD_RELOAD_PRONE_DEPLOYED_30CAL,	false },
+
+	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_30CAL,					false },
+	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_30CAL,				false },
+};
+
+IMPLEMENT_ACTTABLE( CWeapon30cal );
+
+bool CWeapon30cal::Reload( void )
+{
+	if( !IsDeployed() )
+	{
+#ifdef CLIENT_DLL
+		CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+
+		if ( pPlayer )
+			pPlayer->HintMessage( HINT_MG_DEPLOY_TO_RELOAD );
+#endif
+		return false;
+	}
+
+	return BaseClass::Reload();
+}
+
+void CWeapon30cal::PrimaryAttack( void )
+{
+	if ( m_iClip1 <= 0 )
+	{
+		if (m_bFireOnEmpty)
+		{
+			PlayEmptySound();
+			m_flNextPrimaryAttack = gpGlobals->curtime + 0.2;
+		}
+
+		return;
+	}
+
+#ifdef CLIENT_DLL
+	C_DODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+#else
+	CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+#endif
+
+	Assert( pPlayer );
+
+	if( !IsDeployed() )
+	{
+#ifdef CLIENT_DLL 
+		pPlayer->HintMessage( HINT_MG_FIRE_UNDEPLOYED );
+#endif
+		pPlayer->m_Shared.SetSlowedTime( 0.2 );
+
+		float flStamina = pPlayer->m_Shared.GetStamina();
+
+		pPlayer->m_Shared.SetStamina( flStamina - 15 );
+	}
+
+	BaseClass::PrimaryAttack();
+}
+
+Activity CWeapon30cal::GetDrawActivity( void )
+{
+	Activity actDraw;
+
+	if( m_iClip1 <= 0 )
+		actDraw = ACT_VM_DRAW_EMPTY;	
+	else
+		actDraw = ACT_VM_DRAW;
+
+	return actDraw;
+}
+
+Activity CWeapon30cal::GetDeployActivity( void )
+{
+	Activity actDeploy;
+
+	switch ( m_iClip1 )
+	{
+	case 8:
+		actDeploy = ACT_VM_DEPLOY_8;
+		break;
+	case 7:
+		actDeploy = ACT_VM_DEPLOY_7;
+		break;
+	case 6:
+		actDeploy = ACT_VM_DEPLOY_6;
+		break;
+	case 5:
+		actDeploy = ACT_VM_DEPLOY_5;
+		break;
+	case 4:
+		actDeploy = ACT_VM_DEPLOY_4;
+		break;
+	case 3:
+		actDeploy = ACT_VM_DEPLOY_3;
+		break;
+	case 2:
+		actDeploy = ACT_VM_DEPLOY_2;
+		break;
+	case 1:
+		actDeploy = ACT_VM_DEPLOY_1;
+		break;
+	case 0:
+		actDeploy = ACT_VM_DEPLOY_EMPTY;
+		break;
+	default:
+		actDeploy = ACT_VM_DEPLOY;
+		break;
+	}
+
+	return actDeploy;
+}
+
+Activity CWeapon30cal::GetUndeployActivity( void )
+{
+	Activity actUndeploy;
+
+	switch ( m_iClip1 )
+	{
+	case 8:
+		actUndeploy = ACT_VM_UNDEPLOY_8;
+		break;
+	case 7:
+		actUndeploy = ACT_VM_UNDEPLOY_7;
+		break;
+	case 6:
+		actUndeploy = ACT_VM_UNDEPLOY_6;
+		break;
+	case 5:
+		actUndeploy = ACT_VM_UNDEPLOY_5;
+		break;
+	case 4:
+		actUndeploy = ACT_VM_UNDEPLOY_4;
+		break;
+	case 3:
+		actUndeploy = ACT_VM_UNDEPLOY_3;
+		break;
+	case 2:
+		actUndeploy = ACT_VM_UNDEPLOY_2;
+		break;
+	case 1:
+		actUndeploy = ACT_VM_UNDEPLOY_1;
+		break;
+	case 0:
+		actUndeploy = ACT_VM_UNDEPLOY_EMPTY;
+		break;
+	default:
+		actUndeploy = ACT_VM_UNDEPLOY;
+		break;
+	}
+
+	return actUndeploy;
+}
+
+Activity CWeapon30cal::GetIdleActivity( void )
+{
+	Activity actIdle;
+
+	if( IsDeployed() )
+	{
+		switch ( m_iClip1 )
+		{
+		case 8:
+			actIdle = ACT_VM_IDLE_DEPLOYED_8;
+			break;
+		case 7:
+			actIdle = ACT_VM_IDLE_DEPLOYED_7;
+			break;
+		case 6:
+			actIdle = ACT_VM_IDLE_DEPLOYED_6;
+			break;
+		case 5:
+			actIdle = ACT_VM_IDLE_DEPLOYED_5;
+			break;
+		case 4:
+			actIdle = ACT_VM_IDLE_DEPLOYED_4;
+			break;
+		case 3:
+			actIdle = ACT_VM_IDLE_DEPLOYED_3;
+			break;
+		case 2:
+			actIdle = ACT_VM_IDLE_DEPLOYED_2;
+			break;
+		case 1:
+			actIdle = ACT_VM_IDLE_DEPLOYED_1;
+			break;
+		case 0:
+			actIdle = ACT_VM_IDLE_DEPLOYED_EMPTY;
+			break;
+		default:
+			actIdle = ACT_VM_IDLE_DEPLOYED;
+			break;
+		}
+	}
+	else
+	{
+		switch ( m_iClip1 )
+		{
+		case 8:
+			actIdle = ACT_VM_IDLE_8;
+			break;
+		case 7:
+			actIdle = ACT_VM_IDLE_7;
+			break;
+		case 6:
+			actIdle = ACT_VM_IDLE_6;
+			break;
+		case 5:
+			actIdle = ACT_VM_IDLE_5;
+			break;
+		case 4:
+			actIdle = ACT_VM_IDLE_4;
+			break;
+		case 3:
+			actIdle = ACT_VM_IDLE_3;
+			break;
+		case 2:
+			actIdle = ACT_VM_IDLE_2;
+			break;
+		case 1:
+			actIdle = ACT_VM_IDLE_1;
+			break;
+		case 0:
+			actIdle = ACT_VM_IDLE_EMPTY;
+			break;
+		default:
+			actIdle = ACT_VM_IDLE;
+			break;
+		}
+	}
+
+	return actIdle;
+}
+
+Activity CWeapon30cal::GetPrimaryAttackActivity( void )
+{
+	Activity actPrim;
+
+	int maxhax = m_iClip1 + 2;
+
+	if( IsDeployed() )
+	{
+		switch ( maxhax )
+		{
+		case 8:
+			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_8;
+			break;
+		case 7:
+			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_7;
+			break;
+		case 6:
+			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_6;
+			break;
+		case 5:
+			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_5;
+			break;
+		case 4:
+			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_4;
+			break;
+		case 3:
+			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_3;
+			break;
+		case 2:
+			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_2;
+			break;
+		case 1:
+			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_1;
+			break;
+		case 0:
+			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_EMPTY;
+			break;
+		default:
+			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED;
+			break;
+		}
+	}
+	else
+	{
+		switch ( maxhax )
+		{
+		case 8:
+			actPrim = ACT_VM_PRIMARYATTACK_8;
+			break;
+		case 7:
+			actPrim = ACT_VM_PRIMARYATTACK_7;
+			break;
+		case 6:
+			actPrim = ACT_VM_PRIMARYATTACK_6;
+			break;
+		case 5:
+			actPrim = ACT_VM_PRIMARYATTACK_5;
+			break;
+		case 4:
+			actPrim = ACT_VM_PRIMARYATTACK_4;
+			break;
+		case 3:
+			actPrim = ACT_VM_PRIMARYATTACK_3;
+			break;
+		case 2:
+			actPrim = ACT_VM_PRIMARYATTACK_2;
+			break;
+		case 1:
+			actPrim = ACT_VM_PRIMARYATTACK_1;
+			break;
+		case 0:
+			actPrim = ACT_VM_PRIMARYATTACK_EMPTY;
+			break;
+		default:
+			actPrim = ACT_VM_PRIMARYATTACK;
+			break;
+		}
+	}
+
+	return actPrim;
+}
+
+float CWeapon30cal::GetRecoil( void )
+{
+	CDODPlayer *p = ToDODPlayer( GetPlayerOwner() );
+
+	if( p && p->m_Shared.IsInMGDeploy() )
+	{
+		return 0.0f;
+	}
+
+	return 20;
+}

game/shared/dod/weapon_amerknife.cpp

@@ -0,0 +1,77 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodbasemelee.h"
+#include "dod_shareddefs.h"
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponAmerKnife C_WeaponAmerKnife
+
+#endif
+
+
+class CWeaponAmerKnife : public CWeaponDODBaseMelee
+{
+public:
+	DECLARE_CLASS( CWeaponAmerKnife, CWeaponDODBaseMelee );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+	
+	CWeaponAmerKnife()  {}
+
+	virtual Activity GetMeleeActivity( void ) { return ACT_VM_PRIMARYATTACK; }
+
+	virtual DODWeaponID GetWeaponID( void ) const { return WEAPON_AMERKNIFE; }
+
+	virtual void PrimaryAttack()
+	{
+		MeleeAttack( 60, MELEE_DMG_FIST, 0.2f, 0.4f );
+	}
+
+private:
+	CWeaponAmerKnife( const CWeaponAmerKnife & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponAmerKnife, DT_WeaponAmerKnife )
+
+BEGIN_NETWORK_TABLE( CWeaponAmerKnife, DT_WeaponAmerKnife )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponAmerKnife )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_amerknife, CWeaponAmerKnife );
+PRECACHE_WEAPON_REGISTER( weapon_amerknife );
+
+acttable_t CWeaponAmerKnife::m_acttable[] = 
+{
+	{ ACT_DOD_STAND_AIM,					ACT_DOD_STAND_AIM_KNIFE,				false },
+	{ ACT_DOD_CROUCH_AIM,					ACT_DOD_CROUCH_AIM_KNIFE,				false },
+	{ ACT_DOD_CROUCHWALK_AIM,				ACT_DOD_CROUCHWALK_AIM_KNIFE,			false },
+	{ ACT_DOD_WALK_AIM,						ACT_DOD_WALK_AIM_KNIFE,					false },
+	{ ACT_DOD_RUN_AIM,						ACT_DOD_RUN_AIM_KNIFE,					false },
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_KNIFE,				false },
+	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_AIM_KNIFE,			false },
+	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_AIM_KNIFE,				false },
+	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_AIM_KNIFE,				false },
+	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_AIM_KNIFE,			false },
+	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_AIM_KNIFE,					false },
+	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_AIM_KNIFE,					false },
+	{ ACT_SPRINT,							ACT_DOD_SPRINT_AIM_KNIFE,				false },
+
+	{ ACT_RANGE_ATTACK2,					ACT_DOD_PRIMARYATTACK_KNIFE,			false },
+	{ ACT_DOD_SECONDARYATTACK_CROUCH,		ACT_DOD_PRIMARYATTACK_CROUCH_KNIFE,		false },
+	{ ACT_DOD_SECONDARYATTACK_PRONE,		ACT_DOD_PRIMARYATTACK_PRONE_KNIFE,		false },
+
+	// Hand Signals
+	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_KNIFE,					false },
+	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_KNIFE,				false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponAmerKnife );

game/shared/dod/weapon_bar.cpp

@@ -0,0 +1,84 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodfireselect.h"
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponBAR C_WeaponBAR
+
+#endif
+
+
+class CWeaponBAR : public CDODFireSelectWeapon
+{
+public:
+	DECLARE_CLASS( CWeaponBAR, CDODFireSelectWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+	
+	CWeaponBAR()  {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_BAR; }
+
+	// weapon id for stats purposes
+	virtual DODWeaponID GetStatsWeaponID( void )
+	{
+		if ( IsSemiAuto() )
+			return WEAPON_BAR_SEMIAUTO;
+		else 
+			return WEAPON_BAR;
+	}
+
+	virtual float GetRecoil( void ) { return 5.0f; }
+
+private:
+	CWeaponBAR( const CWeaponBAR & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponBAR, DT_WeaponBAR )
+
+BEGIN_NETWORK_TABLE( CWeaponBAR, DT_WeaponBAR )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponBAR )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_bar, CWeaponBAR );
+PRECACHE_WEAPON_REGISTER( weapon_bar );
+
+acttable_t CWeaponBAR::m_acttable[] = 
+{
+	{ ACT_DOD_STAND_AIM,					ACT_DOD_STAND_AIM_BAR,					false },
+	{ ACT_DOD_CROUCH_AIM,					ACT_DOD_CROUCH_AIM_BAR,					false },
+	{ ACT_DOD_CROUCHWALK_AIM,				ACT_DOD_CROUCHWALK_AIM_BAR,				false },
+	{ ACT_DOD_WALK_AIM,						ACT_DOD_WALK_AIM_BAR,					false },
+	{ ACT_DOD_RUN_AIM,						ACT_DOD_RUN_AIM_BAR,					false },
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_BAR,					false },
+	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_IDLE_BAR,				false },
+	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_IDLE_BAR,					false },
+	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_IDLE_BAR,				false },	
+	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_IDLE_BAR,			false },
+	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_IDLE_BAR,					false },
+	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_IDLE_BAR,					false },
+	{ ACT_SPRINT,							ACT_DOD_SPRINT_IDLE_BAR,				false },
+
+	{ ACT_RANGE_ATTACK1,					ACT_DOD_PRIMARYATTACK_BAR,				false },
+	{ ACT_DOD_PRIMARYATTACK_CROUCH,			ACT_DOD_PRIMARYATTACK_BAR,				false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE,			ACT_DOD_PRIMARYATTACK_PRONE_BAR,		false },
+
+	{ ACT_RELOAD,							ACT_DOD_RELOAD_BAR,						false },
+	{ ACT_DOD_RELOAD_CROUCH,				ACT_DOD_RELOAD_CROUCH_BAR,				false },
+	{ ACT_DOD_RELOAD_PRONE,					ACT_DOD_RELOAD_PRONE_BAR,				false },
+
+	// Hand Signals
+	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_K98,					false },
+	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_K98,					false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponBAR );

game/shared/dod/weapon_bazooka.cpp

@@ -0,0 +1,104 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodbaserpg.h"
+
+#if defined( CLIENT_DLL )
+
+	#include "c_dod_player.h"
+	#define CWeaponBazooka C_WeaponBazooka
+
+#else
+
+	#include "rocket_bazooka.h"
+	#include "dod_player.h"
+	
+#endif
+
+
+class CWeaponBazooka : public CDODBaseRocketWeapon
+{
+public:
+	DECLARE_CLASS( CWeaponBazooka, CDODBaseRocketWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+	
+	CWeaponBazooka()  {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_BAZOOKA; }
+
+	virtual void FireRocket( void );
+
+private:
+	CWeaponBazooka( const CWeaponBazooka & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponBazooka, DT_WeaponBazooka )
+
+BEGIN_NETWORK_TABLE( CWeaponBazooka, DT_WeaponBazooka )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponBazooka )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_bazooka, CWeaponBazooka );
+PRECACHE_WEAPON_REGISTER( weapon_bazooka );
+
+acttable_t CWeaponBazooka::m_acttable[] = 
+{
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_BAZOOKA,				false },
+	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_IDLE_BAZOOKA,			false },
+	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_IDLE_BAZOOKA,				false },
+	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_IDLE_BAZOOKA,			false },
+	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_IDLE_BAZOOKA,		false },
+	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_IDLE_BAZOOKA,				false },
+	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_IDLE_BAZOOKA,				false },
+	{ ACT_SPRINT,							ACT_DOD_SPRINT_IDLE_BAZOOKA,			false },
+
+	// Zoomed Aim
+	{ ACT_DOD_IDLE_ZOOMED,					ACT_DOD_STAND_ZOOM_BAZOOKA,				false },
+	{ ACT_DOD_CROUCH_ZOOMED,				ACT_DOD_CROUCH_ZOOM_BAZOOKA,			false },
+	{ ACT_DOD_CROUCHWALK_ZOOMED,			ACT_DOD_CROUCHWALK_ZOOM_BAZOOKA,		false },
+	{ ACT_DOD_WALK_ZOOMED,					ACT_DOD_WALK_ZOOM_BAZOOKA,				false },
+	{ ACT_DOD_PRONE_ZOOMED,					ACT_DOD_PRONE_ZOOM_BAZOOKA,				false },
+	{ ACT_DOD_PRONE_FORWARD_ZOOMED,			ACT_DOD_PRONE_ZOOM_FORWARD_BAZOOKA,		false },
+
+	// Attack ( must be zoomed )
+	{ ACT_RANGE_ATTACK1,					ACT_DOD_PRIMARYATTACK_BAZOOKA,			false },
+	{ ACT_DOD_PRIMARYATTACK_CROUCH,			ACT_DOD_PRIMARYATTACK_BAZOOKA,			false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE,			ACT_DOD_PRIMARYATTACK_PRONE_BAZOOKA,	false },
+
+	// Reload ( zoomed or not, prone or not )
+	{ ACT_RELOAD,							ACT_DOD_RELOAD_BAZOOKA,					false },
+	{ ACT_DOD_RELOAD_CROUCH,				ACT_DOD_RELOAD_CROUCH_BAZOOKA,			false },
+	{ ACT_DOD_RELOAD_PRONE,					ACT_DOD_RELOAD_PRONE_BAZOOKA,			false },	
+	{ ACT_DOD_RELOAD_DEPLOYED,				ACT_DOD_ZOOMLOAD_BAZOOKA,				false },
+	{ ACT_DOD_RELOAD_PRONE_DEPLOYED,		ACT_DOD_ZOOMLOAD_PRONE_BAZOOKA,			false },
+
+	// Hand Signals
+	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_BAZOOKA,				false },
+	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_BAZOOKA,				false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponBazooka );
+
+void CWeaponBazooka::FireRocket( void )
+{
+#ifndef CLIENT_DLL
+
+	CBasePlayer *pPlayer = GetPlayerOwner();
+
+#ifdef DBGFLAG_ASSERT
+	CBazookaRocket *pRocket = 
+#endif //DEBUG		
+		CBazookaRocket::Create( pPlayer->Weapon_ShootPosition(), pPlayer->EyeAngles(), pPlayer );
+
+	Assert( pRocket );
+
+#endif
+}

game/shared/dod/weapon_c96.cpp

@@ -0,0 +1,131 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodfullauto.h"
+
+
+#if defined( CLIENT_DLL )
+
+#define CWeaponC96 C_WeaponC96
+
+#endif
+
+
+class CWeaponC96 : public CDODFullAutoWeapon
+{
+public:
+	DECLARE_CLASS( CWeaponC96, CDODFullAutoWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+
+	CWeaponC96()  {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_C96; }
+
+	virtual Activity GetIdleActivity( void );
+	virtual Activity GetPrimaryAttackActivity( void );
+	virtual Activity GetDrawActivity( void );
+	virtual Activity GetReloadActivity( void );
+
+	virtual float GetRecoil( void ) { return 3.0f; }
+
+private:
+	CWeaponC96( const CWeaponC96 & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponC96, DT_WeaponC96 )
+
+BEGIN_NETWORK_TABLE( CWeaponC96, DT_WeaponC96 )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponC96 )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_c96, CWeaponC96 );
+PRECACHE_WEAPON_REGISTER( weapon_c96 );
+
+acttable_t CWeaponC96::m_acttable[] = 
+{
+	{ ACT_DOD_STAND_AIM,					ACT_DOD_STAND_AIM_C96,			false },
+	{ ACT_DOD_CROUCH_AIM,					ACT_DOD_CROUCH_AIM_C96,			false },
+	{ ACT_DOD_CROUCHWALK_AIM,				ACT_DOD_CROUCHWALK_AIM_C96,		false },
+	{ ACT_DOD_WALK_AIM,						ACT_DOD_WALK_AIM_C96,			false },
+	{ ACT_DOD_RUN_AIM,						ACT_DOD_RUN_AIM_C96,			false },
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_C96,			false },
+	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_IDLE_C96,		false },
+	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_IDLE_C96,			false },
+	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_IDLE_C96,		false },
+	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_IDLE_C96,	false },
+	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_IDLE_C96,			false },
+	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_IDLE_C96,			false },
+	{ ACT_SPRINT,							ACT_DOD_SPRINT_IDLE_C96,		false },
+
+	// Attack ( prone? )
+	{ ACT_RANGE_ATTACK1,					ACT_DOD_PRIMARYATTACK_C96,		false },
+	{ ACT_DOD_PRIMARYATTACK_CROUCH,			ACT_DOD_PRIMARYATTACK_C96,		false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE,			ACT_DOD_PRIMARYATTACK_PRONE_C96,false },
+
+	// Reload ( prone? )
+	{ ACT_RELOAD,							ACT_DOD_RELOAD_C96,				false },
+	{ ACT_DOD_RELOAD_CROUCH,				ACT_DOD_RELOAD_CROUCH_C96,		false },
+	{ ACT_DOD_RELOAD_PRONE,					ACT_DOD_RELOAD_PRONE_C96,		false },
+
+	// Hand Signals
+	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_MP44,			false },
+	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_MP44,			false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponC96 );
+
+Activity CWeaponC96::GetIdleActivity( void )
+{
+	Activity actIdle;
+
+	if( m_iClip1 <= 0 )
+		actIdle = ACT_VM_IDLE_EMPTY;	
+	else
+		actIdle = ACT_VM_IDLE;
+
+	return actIdle;
+}
+
+Activity CWeaponC96::GetPrimaryAttackActivity( void )
+{
+	Activity actPrim;
+
+	if( m_iClip1 <= 0 )
+		actPrim = ACT_VM_PRIMARYATTACK_EMPTY;	
+	else
+		actPrim = ACT_VM_PRIMARYATTACK;
+
+	return actPrim;
+}
+
+Activity CWeaponC96::GetDrawActivity( void )
+{
+	Activity actDraw;
+
+	if( m_iClip1 <= 0 )
+		actDraw = ACT_VM_DRAW_EMPTY;	
+	else
+		actDraw = ACT_VM_DRAW;
+
+	return actDraw;
+}
+
+Activity CWeaponC96::GetReloadActivity( void )
+{
+	Activity actReload;
+
+	if( m_iClip1 <= 0 )
+		actReload = ACT_VM_RELOAD_EMPTY;	
+	else
+		actReload = ACT_VM_RELOAD;
+
+	return actReload;
+}

game/shared/dod/weapon_colt.cpp

@@ -0,0 +1,128 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodsemiauto.h"
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponColt C_WeaponColt
+
+#endif
+
+
+class CWeaponColt : public CDODSemiAutoWeapon
+{
+public:
+	DECLARE_CLASS( CWeaponColt, CDODSemiAutoWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+	
+	CWeaponColt()  {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_COLT; }
+
+	virtual Activity GetIdleActivity( void );
+	virtual Activity GetPrimaryAttackActivity( void );
+	virtual Activity GetDrawActivity( void );
+	virtual Activity GetReloadActivity( void );
+
+	virtual float GetRecoil( void ) { return 1.4f; }
+
+private:
+	CWeaponColt( const CWeaponColt & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponColt, DT_WeaponColt )
+
+BEGIN_NETWORK_TABLE( CWeaponColt, DT_WeaponColt )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponColt )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_colt, CWeaponColt );
+PRECACHE_WEAPON_REGISTER( weapon_colt );
+
+acttable_t CWeaponColt::m_acttable[] = 
+{
+	{ ACT_DOD_STAND_AIM,					ACT_DOD_STAND_AIM_PISTOL,				false },
+	{ ACT_DOD_CROUCH_AIM,					ACT_DOD_CROUCH_AIM_PISTOL,				false },
+	{ ACT_DOD_CROUCHWALK_AIM,				ACT_DOD_CROUCHWALK_AIM_PISTOL,			false },
+	{ ACT_DOD_WALK_AIM,						ACT_DOD_WALK_AIM_PISTOL,				false },
+	{ ACT_DOD_RUN_AIM,						ACT_DOD_RUN_AIM_PISTOL,					false },
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_PISTOL,				false },
+	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_IDLE_PISTOL,			false },
+	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_IDLE_PISTOL,				false },
+	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_IDLE_PISTOL,				false },
+	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_IDLE_PISTOL,			false },
+	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_IDLE_PISTOL,				false },
+	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_IDLE_PISTOL,				false },
+	{ ACT_SPRINT,							ACT_DOD_SPRINT_IDLE_PISTOL,				false },
+
+	{ ACT_RANGE_ATTACK1,					ACT_DOD_PRIMARYATTACK_PISTOL,			false },
+	{ ACT_DOD_PRIMARYATTACK_CROUCH,			ACT_DOD_PRIMARYATTACK_PISTOL,			false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE,			ACT_DOD_PRIMARYATTACK_PRONE_PISTOL,		false },
+
+	{ ACT_RELOAD,							ACT_DOD_RELOAD_PISTOL,					false },
+	{ ACT_DOD_RELOAD_CROUCH,				ACT_DOD_RELOAD_CROUCH_PISTOL,			false },
+	{ ACT_DOD_RELOAD_PRONE,					ACT_DOD_RELOAD_PRONE_PISTOL,			false },
+
+	// Hand Signals
+	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_PISTOL,					false },
+	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_PISTOL,				false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponColt );
+
+Activity CWeaponColt::GetIdleActivity( void )
+{
+	Activity actIdle;
+
+	if( m_iClip1 <= 0 )
+		actIdle = ACT_VM_IDLE_EMPTY;	
+	else
+		actIdle = ACT_VM_IDLE;
+
+	return actIdle;
+}
+
+Activity CWeaponColt::GetPrimaryAttackActivity( void )
+{
+	Activity actPrim;
+
+	if( m_iClip1 <= 0 )
+		actPrim = ACT_VM_PRIMARYATTACK_EMPTY;	
+	else
+		actPrim = ACT_VM_PRIMARYATTACK;
+
+	return actPrim;
+}
+
+Activity CWeaponColt::GetDrawActivity( void )
+{
+	Activity actDraw;
+
+	if( m_iClip1 <= 0 )
+		actDraw = ACT_VM_DRAW_EMPTY;	
+	else
+		actDraw = ACT_VM_DRAW;
+
+	return actDraw;
+}
+
+Activity CWeaponColt::GetReloadActivity( void )
+{
+	Activity actReload;
+
+	if( m_iClip1 <= 0 )
+		actReload = ACT_VM_RELOAD_EMPTY;	
+	else
+        actReload = ACT_VM_RELOAD;
+
+	return actReload;
+}

game/shared/dod/weapon_dodbase.h

@@ -0,0 +1,403 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef WEAPON_DODBASE_H
+#define WEAPON_DODBASE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "dod_playeranimstate.h"
+#include "dod_weapon_parse.h"
+
+#if defined( CLIENT_DLL )
+	#define CWeaponDODBase C_WeaponDODBase
+#endif
+
+extern int	AliasToWeaponID( const char *alias );
+extern const char *WeaponIDToAlias( int id );
+extern bool	IsPrimaryWeapon( int id );
+extern bool IsSecondaryWeapon( int id );
+
+class CDODPlayer;
+
+// These are the names of the ammo types that go in the CAmmoDefs and that the 
+// weapon script files reference.
+
+#define DOD_AMMO_SUBMG		"DOD_AMMO_SUBMG"
+#define DOD_AMMO_ROCKET		"DOD_AMMO_ROCKET"
+#define DOD_AMMO_COLT		"DOD_AMMO_COLT"
+#define DOD_AMMO_P38		"DOD_AMMO_P38"
+#define DOD_AMMO_C96		"DOD_AMMO_C96"	
+#define DOD_AMMO_WEBLEY		"DOD_AMMO_WEBLEY"
+#define DOD_AMMO_GARAND		"DOD_AMMO_GARAND"
+#define DOD_AMMO_K98		"DOD_AMMO_K98"
+#define DOD_AMMO_M1CARBINE	"DOD_AMMO_M1CARBINE"
+#define DOD_AMMO_ENFIELD	"DOD_AMMO_ENFIELD"
+#define DOD_AMMO_SPRING		"DOD_AMMO_SPRING"
+#define DOD_AMMO_FG42		"DOD_AMMO_FG42"		
+#define DOD_AMMO_BREN		"DOD_AMMO_BREN"
+#define DOD_AMMO_BAR		"DOD_AMMO_BAR"		
+#define DOD_AMMO_30CAL		"DOD_AMMO_30CAL"	
+#define DOD_AMMO_MG34		"DOD_AMMO_MG34"		
+#define DOD_AMMO_MG42		"DOD_AMMO_MG42"
+#define DOD_AMMO_HANDGRENADE	"DOD_AMMO_HANDGRENADE"
+#define DOD_AMMO_HANDGRENADE_EX	"DOD_AMMO_HANDGRENADE_EX"	// the EX is for EXploding! :)
+#define DOD_AMMO_STICKGRENADE	"DOD_AMMO_STICKGRENADE"
+#define DOD_AMMO_STICKGRENADE_EX	"DOD_AMMO_STICKGRENADE_EX"
+#define DOD_AMMO_SMOKEGRENADE_US	"DOD_AMMO_SMOKEGRENADE_US"
+#define DOD_AMMO_SMOKEGRENADE_GER	"DOD_AMMO_SMOKEGRENADE_GER"
+#define DOD_AMMO_SMOKEGRENADE_US_LIVE	"DOD_AMMO_SMOKEGRENADE_US_LIVE"
+#define DOD_AMMO_SMOKEGRENADE_GER_LIVE	"DOD_AMMO_SMOKEGRENADE_GER_LIVE"
+#define DOD_AMMO_RIFLEGRENADE_US		"DOD_AMMO_RIFLEGRENADE_US"
+#define DOD_AMMO_RIFLEGRENADE_GER		"DOD_AMMO_RIFLEGRENADE_GER"
+#define DOD_AMMO_RIFLEGRENADE_US_LIVE	"DOD_AMMO_RIFLEGRENADE_US_LIVE"
+#define DOD_AMMO_RIFLEGRENADE_GER_LIVE	"DOD_AMMO_RIFLEGRENADE_GER_LIVE"
+
+
+
+#define CROSSHAIR_CONTRACT_PIXELS_PER_SECOND	7.0f
+
+// Given an ammo type (like from a weapon's GetPrimaryAmmoType()), this compares it
+// against the ammo name you specify.
+// MIKETODO: this should use indexing instead of searching and strcmp()'ing all the time.
+bool IsAmmoType( int iAmmoType, const char *pAmmoName );
+
+
+typedef enum
+{
+	WEAPON_NONE = 0,
+
+	//Melee
+	WEAPON_AMERKNIFE,
+	WEAPON_SPADE,
+
+	//Pistols
+	WEAPON_COLT,
+	WEAPON_P38,
+	WEAPON_C96,
+
+	//Rifles
+	WEAPON_GARAND,
+	WEAPON_M1CARBINE,
+	WEAPON_K98,
+	
+	//Sniper Rifles
+	WEAPON_SPRING,
+	WEAPON_K98_SCOPED,
+
+	//SMG
+	WEAPON_THOMPSON,
+	WEAPON_MP40,
+	WEAPON_MP44,
+	WEAPON_BAR,
+
+	//Machine guns
+	WEAPON_30CAL,
+	WEAPON_MG42,
+
+	//Rocket weapons
+	WEAPON_BAZOOKA,
+	WEAPON_PSCHRECK,
+
+	//Grenades
+	WEAPON_FRAG_US,
+	WEAPON_FRAG_GER,
+
+	WEAPON_FRAG_US_LIVE,
+	WEAPON_FRAG_GER_LIVE,
+
+	WEAPON_SMOKE_US,
+	WEAPON_SMOKE_GER,
+
+	WEAPON_RIFLEGREN_US,
+	WEAPON_RIFLEGREN_GER,
+
+	WEAPON_RIFLEGREN_US_LIVE,
+	WEAPON_RIFLEGREN_GER_LIVE,
+
+	// not actually separate weapons, but defines used in stats recording
+	// find a better way to do this without polluting the list of actual weapons.
+	WEAPON_THOMPSON_PUNCH,
+	WEAPON_MP40_PUNCH,
+
+	WEAPON_GARAND_ZOOMED,	
+	WEAPON_K98_ZOOMED,
+	WEAPON_SPRING_ZOOMED,
+	WEAPON_K98_SCOPED_ZOOMED,
+
+	WEAPON_30CAL_UNDEPLOYED,
+	WEAPON_MG42_UNDEPLOYED,
+
+	WEAPON_BAR_SEMIAUTO,
+	WEAPON_MP44_SEMIAUTO,
+		
+	WEAPON_MAX,		// number of weapons weapon index
+
+} DODWeaponID;
+
+
+//Class Heirarchy for dod weapons
+
+/*
+
+  CWeaponDODBase
+	|
+	|
+	|--> CWeaponDODBaseMelee
+	|		|
+	|		|--> CWeaponSpade
+	|		|--> CWeaponUSKnife
+	|
+	|--> CWeaponDODBaseGrenade
+	|		|
+	|		|--> CWeaponHandgrenade
+	|		|--> CWeaponStickGrenade
+	|		|--> CWeaponSmokeGrenadeUS
+	|		|--> CWeaponSmokeGrenadeGER
+	|
+	|--> CWeaponBaseRifleGrenade
+	|		|
+	|		|--> CWeaponRifleGrenadeUS
+	|		|--> CWeaponRifleGrenadeGER
+	|
+	|--> CDODBaseRocketWeapon
+	|		|
+	|		|--> CWeaponBazooka
+	|		|--> CWeaponPschreck
+	|
+	|--> CWeaponDODBaseGun
+			|
+			|--> CDODFullAutoWeapon
+			|		|
+			|		|--> CWeaponC96
+			|		|
+			|		|--> CDODFullAutoPunchWeapon
+			|		|		|
+			|		|		|--> CWeaponThompson
+			|		|		|--> CWeaponMP40
+			|		|
+			|		|--> CDODBipodWeapon
+			|				|
+			|				|->	CWeapon30Cal
+			|				|->	CWeaponMG42
+			|
+			|--> CDODFireSelectWeapon
+			|		|
+			|		|--> CWeaponMP44
+			|		|--> CWeaponBAR
+			|
+			|
+			|--> CDODSemiAutoWeapon
+					|
+					|--> CWeaponColt
+					|--> CWeaponP38
+					|--> CWeaponM1Carbine
+					|--> CDODSniperWeapon
+						|
+						|--> CWeaponSpring
+						|--> CWeaponScopedK98
+						|--> CWeaponGarand
+						|--> CWeaponK98
+
+*/
+
+void FindHullIntersection( const Vector &vecSrc, trace_t &tr, const Vector &mins, const Vector &maxs, CBaseEntity *pEntity );
+
+typedef enum
+{
+	Primary_Mode = 0,
+	Secondary_Mode,
+} DODWeaponMode;
+
+
+class CWeaponDODBase : public CBaseCombatWeapon
+{
+public:
+	DECLARE_CLASS( CWeaponDODBase, CBaseCombatWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+
+	CWeaponDODBase();
+
+	#ifdef GAME_DLL
+		DECLARE_DATADESC();
+
+		virtual void CheckRespawn();
+		virtual CBaseEntity* Respawn();
+		
+		virtual const Vector& GetBulletSpread();
+		virtual float	GetDefaultAnimSpeed();
+
+		virtual void	ItemBusyFrame();
+		virtual bool	ShouldRemoveOnRoundRestart();
+
+		void Materialize();
+		void AttemptToMaterialize();
+		
+	#else
+
+		void PlayWorldReloadSound( CDODPlayer *pPlayer );
+
+	#endif
+
+	virtual bool	DefaultReload( int iClipSize1, int iClipSize2, int iActivity );
+
+	virtual bool	Holster( CBaseCombatWeapon *pSwitchingTo );
+	virtual void	Drop( const Vector &vecVelocity );
+	virtual void	AddViewmodelBob( CBaseViewModel *viewmodel, Vector &origin, QAngle &angles );
+	virtual	float	CalcViewmodelBob( void );
+	// All predicted weapons need to implement and return true
+	virtual bool	IsPredicted() const;
+
+	virtual int	    ObjectCaps( void ) { return BaseClass::ObjectCaps() | FCAP_USE_IN_RADIUS; }
+
+	CBasePlayer* GetPlayerOwner() const;
+	CDODPlayer* GetDODPlayerOwner() const;
+
+	virtual void WeaponIdle( void );
+	virtual Activity GetIdleActivity( void );
+
+	// Get DOD-specific weapon data.
+	CDODWeaponInfo const	&GetDODWpnData() const;
+
+	// Get specific DOD weapon ID (ie: WEAPON_GARAND, etc)
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_NONE; }
+	virtual DODWeaponID GetStatsWeaponID( void )	{ return GetWeaponID(); }
+	virtual DODWeaponID GetAltWeaponID( void ) const	{ return WEAPON_NONE; }
+
+	// return true if this weapon is an instance of the given weapon type (ie: "IsA" WEAPON_GLOCK)
+	bool IsA( DODWeaponID id ) const						{ return GetWeaponID() == id; }
+
+	// return true if this weapon has a silencer equipped
+	virtual bool IsSilenced( void ) const				{ return false; }
+
+	void KickBack( float up_base, float lateral_base, float up_modifier, float lateral_modifier, float up_max, float lateral_max, int direction_change );
+
+	virtual void SetWeaponModelIndex( const char *pName );
+
+	virtual bool CanDrop( void ) { return false; }
+
+	virtual bool ShouldDrawCrosshair( void ) { return true; }
+	virtual bool ShouldDrawViewModel( void ) { return true; }
+	virtual bool ShouldDrawMuzzleFlash( void ) { return true; }
+
+	virtual float GetWeaponAccuracy( float flPlayerSpeed ) { return 0; }
+
+	virtual bool HideViewModelWhenZoomed( void ) { return false; }
+
+	virtual bool CanAttack( void );
+	virtual bool ShouldAutoReload( void );
+
+	CNetworkVar( int, m_iReloadModelIndex );
+	CNetworkVector( m_vInitialDropVelocity );
+
+	virtual void FinishReload( void	) {}
+
+public:
+	#if defined( CLIENT_DLL )
+
+		virtual void	ProcessMuzzleFlashEvent();
+		virtual bool	ShouldPredict();
+
+
+		virtual void	PostDataUpdate( DataUpdateType_t type );
+		virtual void	OnDataChanged( DataUpdateType_t type );
+
+		virtual bool	OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options );
+
+		virtual bool ShouldAutoEjectBrass( void );
+		virtual bool GetEjectBrassShellType( void );
+
+		void SetUseAltModel( bool bUseAlt );
+		virtual int GetWorldModelIndex( void );
+		virtual void CheckForAltWeapon( int iCurrentState );
+
+		virtual Vector GetDesiredViewModelOffset( C_DODPlayer *pOwner );
+		virtual float GetViewModelSwayScale( void ) { return 1.0; }
+
+		virtual void OnWeaponDropped( void ) {}
+
+		virtual bool ShouldDraw( void );
+
+		float			m_flCrosshairDistance;
+		int				m_iAmmoLastCheck;
+		int				m_iAlpha;
+		int				m_iScopeTextureID;
+
+		bool			m_bUseAltWeaponModel;	//use alternate left handed world model? reset on new sequence
+	#else
+
+		virtual bool	Reload();
+		virtual void	Spawn();
+
+		void			SetDieThink( bool bDie );
+		void			Die( void );
+
+		void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+
+	#endif
+
+	virtual void OnPickedUp( CBaseCombatCharacter *pNewOwner );
+
+	bool IsUseable();
+	virtual bool	CanDeploy( void );
+	virtual bool	CanHolster( void );
+	virtual bool	SendWeaponAnim( int iActivity );
+	virtual void	Precache( void );
+	virtual bool	CanBeSelected( void );
+	virtual bool	DefaultDeploy( char *szViewModel, char *szWeaponModel, int iActivity, char *szAnimExt );
+	virtual bool	Deploy();
+	bool PlayEmptySound();
+	virtual void	ItemPostFrame();
+
+	virtual const char		*GetViewModel( int viewmodelindex = 0 ) const;
+
+	bool	m_bInAttack;		//True after a semi-auto weapon fires - will not fire a second time on the same button press
+
+	void SetExtraAmmoCount( int count ) { m_iExtraPrimaryAmmo = count; }
+	int GetExtraAmmoCount( void ) { return m_iExtraPrimaryAmmo; }
+
+	virtual const char *GetSecondaryDeathNoticeName( void ) { return "world"; }
+
+	virtual CBaseEntity *MeleeAttack( int iDamageAmount, int iDamageType, float flDmgDelay, float flAttackDelay );
+	void EXPORT Smack( void );
+	//Secondary Attacks
+	void RifleButt( void );
+	void Bayonet( void );
+	void Punch( void );
+
+	virtual Activity GetMeleeActivity( void ) { return ACT_VM_SECONDARYATTACK; }
+	virtual Activity GetStrongMeleeActivity( void ) { return ACT_VM_SECONDARYATTACK; }
+
+	virtual float GetRecoil( void ) { return 0.0f; }
+
+protected:
+	CNetworkVar( float, m_flSmackTime );
+	int m_iSmackDamage;
+	int m_iSmackDamageType;
+	EHANDLE m_pTraceHitEnt;
+	trace_t m_trHit;
+
+	int		m_iAltFireHint;
+
+private:
+
+	void EjectBrassLate();
+
+	float	m_flDecreaseShotsFired;
+
+	CWeaponDODBase( const CWeaponDODBase & );
+
+	int		m_iExtraPrimaryAmmo;
+
+#ifdef CLIENT_DLL
+	int m_iCrosshairTexture;
+#endif
+};
+
+
+#endif // WEAPON_DODBASE_H

game/shared/dod/weapon_dodbasebomb.cpp

@@ -0,0 +1,375 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodbasebomb.h"
+
+
+#ifdef CLIENT_DLL
+	#include "c_dod_player.h"
+#else
+	#include "dod_player.h"
+	#include "dod_bombtarget.h"
+	#include "collisionutils.h"
+	#include "in_buttons.h"
+#endif
+
+
+IMPLEMENT_NETWORKCLASS_ALIASED( DODBaseBombWeapon, DT_BaseBombWeapon )
+
+
+BEGIN_NETWORK_TABLE( CDODBaseBombWeapon, DT_BaseBombWeapon )
+
+#ifdef CLIENT_DLL
+	//RecvPropBool( RECVINFO(m_bDeployed) )
+#else
+	//SendPropBool( SENDINFO(m_bDeployed) )
+#endif
+
+END_NETWORK_TABLE()
+
+
+BEGIN_PREDICTION_DATA( CDODBaseBombWeapon )
+END_PREDICTION_DATA()
+
+#ifndef CLIENT_DLL
+
+BEGIN_DATADESC( CDODBaseBombWeapon )
+END_DATADESC()
+
+#endif
+
+LINK_ENTITY_TO_CLASS( weapon_basebomb, CDODBaseBombWeapon );
+PRECACHE_WEAPON_REGISTER( weapon_basebomb );
+
+acttable_t CDODBaseBombWeapon::m_acttable[] = 
+{
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONEWALK_IDLE_PISTOL,			false },	//?
+	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_IDLE_PISTOL,			false },	//?
+	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_IDLE_TNT,					false },
+	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_IDLE_TNT,				false },	//?
+	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_IDLE_TNT,			false },
+	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_IDLE_TNT,					false },
+	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_IDLE_TNT,					false },
+	{ ACT_SPRINT,							ACT_DOD_SPRINT_IDLE_TNT,				false },
+
+	// Hand Signals
+	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_PISTOL,					false },
+	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_PISTOL,				false },
+};
+
+IMPLEMENT_ACTTABLE( CDODBaseBombWeapon );
+
+CDODBaseBombWeapon::CDODBaseBombWeapon()
+{
+}
+
+void CDODBaseBombWeapon::Spawn( )
+{
+	WEAPON_FILE_INFO_HANDLE	hWpnInfo = LookupWeaponInfoSlot( GetClassname() );
+
+	Assert( hWpnInfo != GetInvalidWeaponInfoHandle() );
+
+	CDODWeaponInfo *pWeaponInfo = dynamic_cast< CDODWeaponInfo* >( GetFileWeaponInfoFromHandle( hWpnInfo ) );
+
+	Assert( pWeaponInfo && "Failed to get CDODWeaponInfo in weapon spawn" );
+
+	m_pWeaponInfo = pWeaponInfo;
+
+	SetPlanting( false );
+
+	BaseClass::Spawn();
+}
+
+void CDODBaseBombWeapon::Precache()
+{
+	BaseClass::Precache();
+}
+
+bool CDODBaseBombWeapon::Deploy( )
+{
+#ifdef CLIENT_DLL
+	CDODPlayer *pPlayer = GetDODPlayerOwner();
+
+	if ( pPlayer )
+	{
+		pPlayer->HintMessage( HINT_BOMB_FIRST_SELECT );
+	}
+#endif
+
+	return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), GetDrawActivity(), (char*)GetAnimPrefix() );
+}
+
+void CDODBaseBombWeapon::PrimaryAttack()
+{
+#ifndef CLIENT_DLL
+	if ( IsPlanting() )
+	{
+		CDODBombTarget *pTarget = (CDODBombTarget *)m_hBombTarget.Get();
+		CBasePlayer *pPlayer = GetPlayerOwner();
+
+		if ( !pTarget || !pPlayer )
+		{
+			CancelPlanting();
+			return;
+		}
+
+		if ( pTarget->CanPlantHere( GetDODPlayerOwner() ) == false )
+		{
+			// if the target is not active anymore, cancel ( someone planted there already? )
+			CancelPlanting();
+		}
+		else if ( ( pTarget->GetAbsOrigin() - pPlayer->WorldSpaceCenter() ).Length() > DOD_BOMB_PLANT_RADIUS )
+		{
+			// if we're too far away, cancel
+			CancelPlanting();			
+		}
+		else if ( IsLookingAtBombTarget( pPlayer, pTarget ) == false || ( pPlayer->GetFlags() & FL_ONGROUND ) == 0 )
+		{
+			// not looking at the target anymore
+			CancelPlanting();
+		}
+		else if ( gpGlobals->curtime > m_flPlantCompleteTime )
+		{
+			// we finished the plant
+			CompletePlant();
+		}
+		else
+		{
+			m_flNextPlantCheck = gpGlobals->curtime + 0.2;
+		}
+
+		return;
+	}
+
+	// find nearby, visible bomb targets
+	CBaseEntity *pEnt = NULL;
+	CDODBombTarget *pBestTarget = NULL;
+
+	float flBestDist = FLT_MAX;
+
+	CDODPlayer *pPlayer = GetDODPlayerOwner();
+
+	if ( !pPlayer )
+		return;
+	
+	while( ( pEnt = gEntList.FindEntityByClassname( pEnt, "dod_bomb_target" ) ) != NULL )
+	{
+		CDODBombTarget *pTarget = static_cast<CDODBombTarget *>( pEnt );
+
+		if ( !pTarget->CanPlantHere( pPlayer ) )
+			continue;
+
+		Vector pos = pPlayer->WorldSpaceCenter();
+
+		float flDist = ( pos - pTarget->GetAbsOrigin() ).Length();
+
+		// if we are looking directly at a bomb target and it is within our radius, that automatically wins
+		if ( flDist < flBestDist &&
+			flDist < DOD_BOMB_PLANT_RADIUS &&
+			IsLookingAtBombTarget( pPlayer, pTarget ) &&
+			( pPlayer->GetFlags() & FL_ONGROUND ) )
+		{
+			flBestDist = flDist;
+			pBestTarget = pTarget;
+		}
+	}
+
+	if ( pBestTarget )
+	{
+		StartPlanting( pBestTarget );
+	}
+
+	m_flNextPlantCheck = gpGlobals->curtime + 0.2;
+
+	// true if the player is not holding primary attack
+	m_bUsePlant = !( pPlayer->m_nButtons & (IN_ATTACK|IN_ATTACK2) );
+#endif
+}
+
+void CDODBaseBombWeapon::SecondaryAttack()
+{
+	PrimaryAttack();
+}
+
+#ifndef CLIENT_DLL
+void CDODBaseBombWeapon::StartPlanting( CDODBombTarget *pTarget )
+{
+	// we have already checked that we can plant here
+
+	// store a pointer to the target we're bombing
+	m_hBombTarget = pTarget;
+
+	// must do this after setting the bomb target as we tell the planter
+	// what target they are at
+	SetPlanting( true );
+
+	// set the timer for when we'll be done
+	m_flPlantCompleteTime = gpGlobals->curtime + DOD_BOMB_PLANT_TIME;
+
+	// play the planting animation
+	SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+
+	CDODPlayer *pPlayer = GetDODPlayerOwner();
+
+	if ( pPlayer )
+	{
+		pPlayer->DoAnimationEvent( PLAYERANIMEVENT_PLANT_TNT );
+
+		pPlayer->SetMaxSpeed( 1 );
+
+		pPlayer->SetProgressBarTime( DOD_BOMB_PLANT_TIME );
+	}
+}
+
+bool CDODBaseBombWeapon::CancelPlanting( void )
+{
+	bool bHolster = false;
+
+	SetPlanting( false );
+
+	// play a stop animation
+	SendWeaponAnim( ACT_VM_IDLE );
+
+	CDODPlayer *pPlayer = GetDODPlayerOwner();
+
+	if ( pPlayer )
+	{
+		pPlayer->DoAnimationEvent( PLAYERANIMEVENT_CANCEL_GESTURES );
+
+		// restore player speed
+		pPlayer->SetMaxSpeed( 600 );
+
+		pPlayer->ResetProgressBar();
+
+		if ( m_bUsePlant )
+		{
+			pPlayer->SelectLastItem();
+
+			bHolster = true;
+		}
+	}
+
+	return bHolster;
+}
+
+void CDODBaseBombWeapon::CompletePlant( void )
+{
+	CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+
+	if ( pPlayer )
+	{
+		SetPlanting( false );
+
+		// restore player speed
+		GetDODPlayerOwner()->SetMaxSpeed( 600 );
+
+		// Tell the target that we finished planting the bomb
+		((CDODBombTarget *)m_hBombTarget.Get())->CompletePlanting( pPlayer );
+
+		// destroy the bomb weapon
+		pPlayer->Weapon_Drop( this, NULL, NULL );
+		UTIL_Remove(this);
+
+		pPlayer->ResetProgressBar();
+
+		pPlayer->SelectLastItem();
+	}
+}
+
+bool CDODBaseBombWeapon::IsLookingAtBombTarget( CBasePlayer *pPlayer, CDODBombTarget *pTarget )
+{
+	Vector forward;
+	AngleVectors( pPlayer->EyeAngles(), &forward );
+
+	Vector toBomb = pTarget->GetAbsOrigin() - pPlayer->EyePosition();
+	toBomb.NormalizeInPlace();
+
+	return ( DotProduct( forward, toBomb ) >= 0.8 );
+}
+
+#endif
+
+void CDODBaseBombWeapon::ItemPostFrame()
+{
+#ifndef CLIENT_DLL
+	CBasePlayer *pPlayer = GetPlayerOwner();
+
+	if ( !pPlayer )
+		return;
+
+	if ( pPlayer->m_nButtons & (IN_ATTACK|IN_ATTACK2) )
+	{
+		PrimaryAttack();
+	}
+	// Only use the time check if we are planting with the +use key
+	// adds a slight lag to breaking the player lock otherwise
+	else if ( !m_bUsePlant || m_flNextPlantCheck < gpGlobals->curtime )
+	{
+		if ( IsPlanting() )
+		{
+			// reset all planting
+			bool bHolster = CancelPlanting();
+
+			// sometimes after canceling we put the weapon away and switch
+			// to our last weapon. In that case, we don't want to send any more
+			// anim calls b/c it confuses the client.
+			if ( bHolster )
+			{
+				// we've put this weapon away, stop everything
+				return;
+			}
+
+			// anim now
+			m_flTimeWeaponIdle = 0;
+		}
+		
+		// idle
+		if (m_flTimeWeaponIdle > gpGlobals->curtime)
+			return;
+
+		SendWeaponAnim( GetIdleActivity() );
+
+		m_flTimeWeaponIdle = gpGlobals->curtime + SequenceDuration();
+
+		// if we're not planting, why do we have the bomb out?
+		// switch to our next best weapon
+		pPlayer->SelectLastItem();
+	}
+	
+#endif	// CLIENT_DLL
+}
+
+bool CDODBaseBombWeapon::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+#ifndef CLIENT_DLL
+	if ( IsPlanting() )
+		CancelPlanting();
+#endif
+
+	return BaseClass::Holster( pSwitchingTo );
+}
+
+void CDODBaseBombWeapon::SetPlanting( bool bPlanting )
+{
+	m_bPlanting = bPlanting;
+
+#ifndef CLIENT_DLL
+	CDODPlayer *pPlayer = GetDODPlayerOwner();
+
+	if ( pPlayer )
+	{
+		pPlayer->SetPlanting( m_bPlanting ? (CDODBombTarget *)m_hBombTarget.Get() : NULL );
+	}
+#endif
+}
+
+bool CDODBaseBombWeapon::IsPlanting( void )
+{
+	return m_bPlanting;
+}

game/shared/dod/weapon_dodbasebomb.h

@@ -0,0 +1,87 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef WEAPON_DODBASEBOMB_H
+#define WEAPON_DODBASEBOMB_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "weapon_dodbase.h"
+
+#if defined( CLIENT_DLL )
+
+#define CDODBaseBombWeapon C_DODBaseBombWeapon
+
+#else
+
+#include "dod_bombtarget.h"
+
+#endif
+
+//-----------------------------------------------------------------------------
+// RPG
+//-----------------------------------------------------------------------------
+class CDODBaseBombWeapon : public CWeaponDODBase
+{
+public:
+	DECLARE_CLASS( CDODBaseBombWeapon, CWeaponDODBase );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+
+	CDODBaseBombWeapon();
+
+	virtual void Spawn();
+	virtual void Precache( void );
+	virtual bool Deploy();
+	virtual void PrimaryAttack();
+	virtual void SecondaryAttack();
+	virtual bool Holster( CBaseCombatWeapon *pSwitchingTo );
+
+	virtual void ItemPostFrame( void );
+
+	virtual bool CanDrop( void ) { return false; }
+	virtual DODWeaponID GetWeaponID( void ) const { return WEAPON_NONE; }
+	virtual bool ShouldDrawCrosshair( void ) { return false; }
+	virtual bool HasPrimaryAmmo() { return true; }
+	virtual bool CanBeSelected() { return false; }
+
+#ifndef CLIENT_DLL
+	void StartPlanting( CDODBombTarget *pTarget );
+	bool CancelPlanting( void );
+	void CompletePlant( void );
+	bool IsLookingAtBombTarget( CBasePlayer *pPlayer, CDODBombTarget *pTarget );
+#endif
+
+	void SetPlanting( bool bPlanting );
+	bool IsPlanting( void );
+
+protected:
+	CDODWeaponInfo *m_pWeaponInfo;
+
+private:
+	CDODBaseBombWeapon( const CDODBaseBombWeapon & );
+
+	bool m_bPlanting;
+
+	// pointer to the dod_bomb_target that we're planting at
+	EHANDLE m_hBombTarget;
+
+	// when the plant will be complete
+	float m_flPlantCompleteTime;
+
+	bool m_bUsePlant;	// player hit +use to start this plant
+	float m_flNextPlantCheck;
+
+#ifndef CLIENT_DLL
+	DECLARE_DATADESC();
+#endif
+};
+
+#endif // WEAPON_DODBASEBOMB_H

game/shared/dod/weapon_dodbasegrenade.cpp

@@ -0,0 +1,474 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodbasegrenade.h"
+#include "in_buttons.h"
+#include "dod_gamerules.h"
+
+
+#if defined( CLIENT_DLL )
+	#include "c_dod_player.h"
+#else
+	#include "dod_player.h"
+#endif
+
+extern ConVar dod_bonusround;
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponDODBaseGrenade, DT_WeaponDODBaseGrenade )
+
+BEGIN_NETWORK_TABLE(CWeaponDODBaseGrenade, DT_WeaponDODBaseGrenade)
+#if !defined( CLIENT_DLL )
+	SendPropBool( SENDINFO( m_bPinPulled ) ),
+	SendPropBool( SENDINFO( m_bArmed ) ),
+#else
+	RecvPropBool( RECVINFO( m_bPinPulled ) ),
+	RecvPropBool( RECVINFO( m_bArmed ) ),
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponDODBaseGrenade )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_basedodgrenade, CWeaponDODBaseGrenade );
+
+acttable_t CWeaponDODBaseGrenade::m_acttable[] = 
+{
+	// Move this out to the specific grenades???
+	{ ACT_DOD_STAND_AIM,					ACT_DOD_STAND_AIM_GREN_FRAG,				false },
+	{ ACT_DOD_CROUCH_AIM,					ACT_DOD_CROUCH_AIM_GREN_FRAG,				false },
+	{ ACT_DOD_CROUCHWALK_AIM,				ACT_DOD_CROUCHWALK_AIM_GREN_FRAG,			false },
+	{ ACT_DOD_WALK_AIM,						ACT_DOD_WALK_AIM_GREN_FRAG,					false },
+	{ ACT_DOD_RUN_AIM,						ACT_DOD_RUN_AIM_GREN_FRAG,					false },
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_GREN_FRAG,				false },
+	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_AIM_GREN_FRAG,			false },
+	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_AIM_GREN_FRAG,				false },
+	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_AIM_GREN_FRAG,				false },
+	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_AIM_GREN_FRAG,			false },
+	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_AIM_GREN_FRAG,					false },
+	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_AIM_GREN_FRAG,					false },
+	{ ACT_SPRINT,							ACT_DOD_SPRINT_AIM_GREN_FRAG,				false },
+
+	{ ACT_RANGE_ATTACK1,				ACT_DOD_PRIMARYATTACK_GREN_FRAG,		false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE,		ACT_DOD_PRIMARYATTACK_PRONE_GREN_FRAG,	false },
+	{ ACT_DOD_PRIMARYATTACK_CROUCH,		ACT_DOD_PRIMARYATTACK_CROUCH_GREN_FRAG, false },
+
+	// Hand Signals
+	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_STICKGRENADE,			false },
+	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_STICKGRENADE,			false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponDODBaseGrenade );
+
+CWeaponDODBaseGrenade::CWeaponDODBaseGrenade()
+{
+	m_bRedraw = false;
+	m_bPinPulled = false;
+	SetArmed( false );
+
+	m_iAltFireHint = HINT_USE_PRIME;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CWeaponDODBaseGrenade::CanHolster( void )
+{
+	// can only holster hand grenades when not primed!
+	return ( m_bPinPulled == false && !IsArmed() );
+}
+
+#ifdef CLIENT_DLL
+
+	void CWeaponDODBaseGrenade::PrimaryAttack()
+	{
+		//nothing on the client
+	}
+
+#else
+
+	BEGIN_DATADESC( CWeaponDODBaseGrenade )
+		DEFINE_FIELD( m_bRedraw, FIELD_BOOLEAN ),
+		DEFINE_INPUTFUNC( FIELD_FLOAT, "DetonateTime", InputSetDetonateTime ),
+	END_DATADESC()
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	//-----------------------------------------------------------------------------
+	void CWeaponDODBaseGrenade::Precache()
+	{
+		PrecacheScriptSound( "Weapon_Grenade.Throw" );
+
+		// Precache all the grenade minimap icons. 
+		PrecacheMaterial( "sprites/minimap_icons/minimap_riflegren_ger" );
+		PrecacheMaterial( "sprites/minimap_icons/minimap_riflegren_us" );
+		PrecacheMaterial( "sprites/minimap_icons/grenade_hltv" );
+		PrecacheMaterial( "sprites/minimap_icons/stick_hltv" );
+		PrecacheMaterial( "sprites/minimap_icons/minimap_smoke_us" );
+		PrecacheMaterial( "sprites/minimap_icons/minimap_smoke_ger" );
+
+		BaseClass::Precache();
+	}
+	
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	//-----------------------------------------------------------------------------
+	bool CWeaponDODBaseGrenade::Deploy()
+	{
+		m_bRedraw = false;
+		m_bPinPulled = false;
+
+		return BaseClass::Deploy();
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	// Output : Returns true on success, false on failure.
+	//-----------------------------------------------------------------------------
+	bool CWeaponDODBaseGrenade::Holster( CBaseCombatWeapon *pSwitchingTo )
+	{
+		m_bRedraw = false;
+
+#ifndef CLIENT_DLL
+		// If they attempt to switch weapons before the throw animation is done, 
+		// allow it, but kill the weapon if we have to.
+
+		CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+
+		if( pPlayer && pPlayer->GetAmmoCount(m_iPrimaryAmmoType) <= 0 )
+		{
+			pPlayer->Weapon_Drop( this, NULL, NULL );
+			UTIL_Remove(this);
+		}
+#endif
+
+		return BaseClass::Holster( pSwitchingTo );
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	// Output : Returns true on success, false on failure.
+	//-----------------------------------------------------------------------------
+	bool CWeaponDODBaseGrenade::Reload()
+	{
+		if ( ( m_bRedraw ) && ( m_flNextPrimaryAttack <= gpGlobals->curtime ) && ( m_flNextSecondaryAttack <= gpGlobals->curtime ) )
+		{
+			//Redraw the weapon
+			SendWeaponAnim( GetDrawActivity() );
+
+			//Update our times
+			m_flNextPrimaryAttack	= gpGlobals->curtime + SequenceDuration();
+			m_flNextSecondaryAttack	= gpGlobals->curtime + SequenceDuration();
+			m_flTimeWeaponIdle = gpGlobals->curtime + SequenceDuration();
+
+			//Mark this as done
+			m_bRedraw = false;
+		}
+
+		return true;
+	}
+
+enum
+{
+	THROW_THROW	= 0,
+	THROW_PRIME
+};
+	
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	//-----------------------------------------------------------------------------
+	void CWeaponDODBaseGrenade::PrimaryAttack()
+	{
+		if ( IsArmed() )	// live grenade already?
+		{
+			StartThrow( THROW_THROW );
+		}
+		else
+		{
+			StartThrow( THROW_PRIME );
+		}
+	}
+
+	void CWeaponDODBaseGrenade::StartThrow( int throwType )
+	{
+		if( GetPlayerOwner()->GetWaterLevel() > 2 )
+		{
+			PlayEmptySound();
+			m_flNextPrimaryAttack = gpGlobals->curtime + 1.0;
+			return;
+		}
+
+		if ( !m_bPinPulled )
+		{
+			m_bPinPulled = true; 
+
+			SendWeaponAnim( GetPrimaryAttackActivity() );
+
+			// Can't prime an already primed grenade!
+			if ( !IsArmed() && throwType == THROW_PRIME )
+			{
+				SetArmed( true );
+
+				m_flDetonateTime = gpGlobals->curtime + GetDetonateTimerLength();
+
+				// start the hissing noise
+			}
+
+			m_flTimeWeaponIdle		= gpGlobals->curtime + SequenceDuration();
+			m_flNextPrimaryAttack	= gpGlobals->curtime + SequenceDuration();
+			m_flNextSecondaryAttack	= gpGlobals->curtime + SequenceDuration();
+		}
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	//-----------------------------------------------------------------------------
+	void CWeaponDODBaseGrenade::ItemPostFrame()
+	{
+		CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+		if ( !pPlayer )
+			return;
+
+		CBaseViewModel *pViewModel = pPlayer->GetViewModel( m_nViewModelIndex );
+		if ( !pViewModel )
+			return;
+
+		if( IsArmed() && gpGlobals->curtime > m_flDetonateTime )
+		{
+			//Drop it!
+			DropGrenade();
+			m_flNextPrimaryAttack = gpGlobals->curtime + 1.0;
+			m_flNextSecondaryAttack = gpGlobals->curtime + 1.0;
+			return;
+		}
+
+		if ( m_bPinPulled &&
+			 !(pPlayer->m_nButtons & IN_ATTACK) && 
+			 !(pPlayer->m_nButtons & IN_ATTACK2) // If they let go of the fire button, they want to throw the grenade.
+			 )
+		{
+			pPlayer->DoAnimationEvent( PLAYERANIMEVENT_THROW_GRENADE );
+
+			ThrowGrenade(false);
+
+			m_bRedraw = true;
+			m_bPinPulled = false;
+			SetArmed( false );
+
+			DecrementAmmo( pPlayer );		
+
+			SendWeaponAnim( ACT_VM_THROW );
+		}
+		else
+		{
+			BaseClass::ItemPostFrame();
+			
+			if ( m_bRedraw )
+			{
+				if (pPlayer->GetAmmoCount(m_iPrimaryAmmoType) <= 0)
+				{
+					pPlayer->Weapon_Drop( this, NULL, NULL );
+					UTIL_Remove(this);
+				}
+				else
+                    Reload();
+			}
+		}
+	}
+
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	// Input  : *pOwner - 
+	//-----------------------------------------------------------------------------
+	void CWeaponDODBaseGrenade::DecrementAmmo( CBaseCombatCharacter *pOwner )
+	{
+		pOwner->RemoveAmmo( 1, m_iPrimaryAmmoType );
+
+		if (pOwner->GetAmmoCount(m_iPrimaryAmmoType) <= 0)
+		{
+            pOwner->Weapon_Drop( this, NULL, NULL );
+			UTIL_Remove(this);
+		}
+	}
+
+	void CWeaponDODBaseGrenade::DropGrenade( void )
+	{
+		CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+		if ( !pPlayer )
+			return;
+
+		pPlayer->DoAnimationEvent( PLAYERANIMEVENT_THROW_GRENADE );
+
+		bool bThrow = true;
+
+		DODRoundState state = DODGameRules()->State_Get();
+
+		// If the player is holding a nade that is going to explode
+		// and the round is over, not allowing them to throw it
+		// just don't emit a grenade.
+		if ( dod_bonusround.GetBool() )
+		{
+			int team = pPlayer->GetTeamNumber();
+
+			if ( ( team == TEAM_ALLIES && state == STATE_AXIS_WIN ) || 
+				( team == TEAM_AXIS && state == STATE_ALLIES_WIN ) )
+			{
+				bThrow = false;
+			}
+		}
+
+		if ( bThrow )
+			ThrowGrenade(true);
+
+		m_bRedraw = true;
+		m_bPinPulled = false;
+		SetArmed( false );
+
+		DecrementAmmo( pPlayer );		
+
+		SendWeaponAnim( ACT_VM_THROW );
+	}
+
+	ConVar dod_grenadespeed( "dod_grenadespeed", "4.2", FCVAR_CHEAT );
+	ConVar dod_grenademaxspeed( "dod_grenademaxspeed", "1400", FCVAR_CHEAT );
+	ConVar dod_grenademinspeed( "dod_grenademinspeed", "500", FCVAR_CHEAT );
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	//-----------------------------------------------------------------------------
+	void CWeaponDODBaseGrenade::ThrowGrenade( bool bDrop )
+	{
+		CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
+		if ( !pPlayer )
+		{
+			Assert( false );
+			return;
+		}
+
+		QAngle angThrow = pPlayer->LocalEyeAngles();
+
+		Vector vForward, vRight, vUp;
+
+		if( angThrow.x > 180 )
+			angThrow.x -= 360;
+
+		if (angThrow.x < 0)
+			angThrow.x = -10 + angThrow.x * ((90 - 10) / 90.0);
+		else
+			angThrow.x = -10 + angThrow.x * ((90 + 10) / 90.0);
+
+		AngleVectors( angThrow, &vForward, &vRight, &vUp );
+		
+		Vector eyes = pPlayer->GetAbsOrigin() + pPlayer->GetViewOffset();
+		Vector vecSrc = eyes + vForward * 16; 	
+
+		// Start with the player's velocity as the grenade vel
+		Vector vecPlayerVel;
+		pPlayer->GetVelocity( &vecPlayerVel, NULL );
+
+		// Get player angles, not eye angles!
+		QAngle angPlayerAngles = pPlayer->GetAbsAngles();
+		Vector vecPlayerForward;
+		AngleVectors( angPlayerAngles, &vecPlayerForward );
+		Vector vecThrow = DotProduct( vecPlayerVel, vecPlayerForward ) * vecPlayerForward;
+
+		if( bDrop )
+		{
+			vecThrow = vForward;
+		}
+		else	// we are throwing the grenade
+		{
+			// change the speed depending on the throw angle
+			// straight down is 0%, straight up is 100%, linear between
+			float flSpeed = ( 90 - angThrow.x ) * dod_grenadespeed.GetFloat();
+
+			//Msg( "speed %.f\n", flSpeed );
+
+			flSpeed = clamp( flSpeed, dod_grenademinspeed.GetFloat(), dod_grenademaxspeed.GetFloat() );
+
+			vecThrow += vForward * flSpeed;
+		}
+
+		trace_t tr;
+		UTIL_TraceLine( eyes, vecSrc, MASK_SOLID, NULL, COLLISION_GROUP_NONE, &tr );
+		
+		// don't go into the ground
+		if( tr.fraction < 1.0 ) 
+		{
+			vecSrc = tr.endpos;
+		}
+
+		float flTimeLeft;
+
+		if ( IsArmed() )
+			flTimeLeft = MAX( 0, m_flDetonateTime - gpGlobals->curtime );
+		else
+			flTimeLeft = GetDetonateTimerLength();
+
+		EmitGrenade( vecSrc, vec3_angle, vecThrow, AngularImpulse(600,random->RandomInt(-1200,1200),0), pPlayer, flTimeLeft );
+
+		pPlayer->EmitSound( "Weapon_Grenade.Throw" );
+
+#ifndef CLIENT_DLL
+		IGameEvent * event = gameeventmanager->CreateEvent( "dod_stats_weapon_attack" );
+		if ( event )
+		{
+			event->SetInt( "attacker", pPlayer->GetUserID() );
+			event->SetInt( "weapon", GetStatsWeaponID() );
+
+			gameeventmanager->FireEvent( event );
+		}
+#endif	//CLIENT_DLL
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	//-----------------------------------------------------------------------------
+	void CWeaponDODBaseGrenade::EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer, float flLifeTime /* = GRENADE_FUSE_LENGTH */ )
+	{
+		Assert( 0 && "CBaseCSGrenade::EmitGrenade should not be called. Make sure to implement this in your subclass!\n" );
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose:
+	//-----------------------------------------------------------------------------
+	bool CWeaponDODBaseGrenade::AllowsAutoSwitchFrom( void ) const
+	{
+		return ( m_bPinPulled == false );
+	}
+
+	void CWeaponDODBaseGrenade::InputSetDetonateTime( inputdata_t &inputdata )
+	{
+		SetDetonateTime( inputdata.value.Float() );
+	}
+
+#endif	// !CLIENT_DLL
+
+Activity CWeaponDODBaseGrenade::GetIdleActivity( void )
+{
+	if ( IsArmed() )
+		return ACT_VM_IDLE_EMPTY;
+	else
+		return ACT_VM_IDLE;
+}
+
+Activity CWeaponDODBaseGrenade::GetPrimaryAttackActivity( void )
+{
+	if ( IsArmed() )
+		return ACT_VM_PRIMARYATTACK_EMPTY;
+	else
+		return ACT_VM_PULLPIN;
+}
+
+Activity CWeaponDODBaseGrenade::GetDrawActivity( void )
+{
+	if ( IsArmed() )
+		return ACT_VM_DRAW_EMPTY;
+	else
+		return ACT_VM_DRAW;
+}
+

game/shared/dod/weapon_dodbasegrenade.h

@@ -0,0 +1,90 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef WEAPON_DODBASEGRENADE_H
+#define WEAPON_DODBASEGRENADE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "weapon_dodbase.h"
+#include "dod_shareddefs.h"
+
+
+#ifdef CLIENT_DLL
+	
+	#define CWeaponDODBaseGrenade C_WeaponDODBaseGrenade
+
+#endif
+
+
+class CWeaponDODBaseGrenade : public CWeaponDODBase
+{
+public:
+	DECLARE_CLASS( CWeaponDODBaseGrenade, CWeaponDODBase );
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+
+	CWeaponDODBaseGrenade();
+
+	virtual void	PrimaryAttack();
+	virtual bool	CanHolster();
+
+	virtual bool IsArmed( void ) { return m_bArmed == true; }
+	void SetArmed( bool bArmed ) { m_bArmed = bArmed; }
+
+	virtual Activity GetIdleActivity( void );
+	virtual Activity GetPrimaryAttackActivity( void );
+	virtual Activity GetDrawActivity( void );
+
+#ifdef CLIENT_DLL
+
+#else
+	DECLARE_DATADESC();
+
+	virtual void	Precache();
+	virtual void	ItemPostFrame();
+	virtual bool    AllowsAutoSwitchFrom( void ) const;
+	virtual bool	Deploy();
+	virtual bool	Holster( CBaseCombatWeapon *pSwitchingTo );
+	virtual bool	Reload();
+
+	void	DecrementAmmo( CBaseCombatCharacter *pOwner );
+
+	void	StartThrow( int iThrowType );
+
+	void	DropGrenade( void );	//forces the grenade to be dropped
+
+	virtual void ThrowGrenade( bool bDrop );
+
+	// Each derived grenade class implements this.
+	virtual void EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer, float flLifeTime = GRENADE_FUSE_LENGTH );
+
+	void SetDetonateTime( float flDetonateTime )
+	{
+		m_flDetonateTime = flDetonateTime;
+		SetArmed( true );
+	}
+
+	void InputSetDetonateTime( inputdata_t &inputdata );
+
+	virtual float GetDetonateTimerLength( void ) { return GRENADE_FUSE_LENGTH; }
+
+protected:
+
+#endif
+
+	bool m_bRedraw;	// Draw the weapon again after throwing a grenade
+	CNetworkVar( bool, m_bPinPulled );	// Set to true when the pin has been pulled but the grenade hasn't been thrown yet.
+	CNetworkVar( bool, m_bArmed );			// is the grenade armed?
+	float m_flDetonateTime;	// what time the grenade will explode ( if > 0 )
+	CWeaponDODBaseGrenade( const CWeaponDODBaseGrenade & ) {}
+};
+
+
+#endif // WEAPON_DODBASEGRENADE_H

game/shared/dod/weapon_dodbasegun.cpp

@@ -0,0 +1,252 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodbasegun.h"
+#include "fx_dod_shared.h"
+//#include "effect_dispatch_data.h"
+
+#ifdef CLIENT_DLL
+	#include "c_dod_player.h"
+	#include "prediction.h"
+#else
+	#include "dod_player.h"
+	#include "te_effect_dispatch.h"
+	#include "util.h"
+	#include "ndebugoverlay.h"
+#endif
+
+#ifndef CLIENT_DLL
+//-----------------------------------------------------------------------------
+// Purpose: Only send to local player if this weapon is the active weapon
+// Input  : *pStruct - 
+//			*pVarData - 
+//			*pRecipients - 
+//			objectID - 
+// Output : void*
+//-----------------------------------------------------------------------------
+void* SendProxy_SendActiveLocalBaseGunDataTable( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID )
+{
+	// Get the weapon entity
+	CBaseCombatWeapon *pWeapon = (CBaseCombatWeapon*)pVarData;
+	if ( pWeapon )
+	{
+		// Only send this chunk of data to the player carrying this weapon
+		CBasePlayer *pPlayer = ToBasePlayer( pWeapon->GetOwner() );
+		if ( pPlayer )
+		{
+			pRecipients->SetOnly( pPlayer->GetClientIndex() );
+			return (void*)pVarData;
+		}
+	}
+
+	return NULL;
+}
+REGISTER_SEND_PROXY_NON_MODIFIED_POINTER( SendProxy_SendActiveLocalBaseGunDataTable );
+#endif
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponDODBaseGun, DT_WeaponDODBaseGun )
+
+BEGIN_NETWORK_TABLE_NOBASE( CWeaponDODBaseGun, DT_LocalActiveWeaponBaseGunData )
+END_NETWORK_TABLE()
+
+BEGIN_NETWORK_TABLE( CWeaponDODBaseGun, DT_WeaponDODBaseGun )
+	#ifdef CLIENT_DLL
+		RecvPropDataTable("LocalActiveWeaponBaseGunData", 0, 0, &REFERENCE_RECV_TABLE(DT_LocalActiveWeaponBaseGunData))
+	#else
+		SendPropDataTable("LocalActiveWeaponBaseGunData", 0, &REFERENCE_SEND_TABLE(DT_LocalActiveWeaponBaseGunData), SendProxy_SendActiveLocalBaseGunDataTable )
+	#endif
+END_NETWORK_TABLE()
+
+#ifdef CLIENT_DLL
+
+	BEGIN_PREDICTION_DATA( CWeaponDODBaseGun )
+	END_PREDICTION_DATA()
+
+#else
+
+	BEGIN_DATADESC( CWeaponDODBaseGun )
+	END_DATADESC()
+
+#endif
+
+LINK_ENTITY_TO_CLASS( weapon_dod_base_gun, CWeaponDODBaseGun );
+
+extern ConVar friendlyfire;
+
+CWeaponDODBaseGun::CWeaponDODBaseGun()
+{
+}
+
+
+void CWeaponDODBaseGun::Spawn()
+{
+	DODBaseGunSpawn();
+
+	SetZoomed( false );
+}
+
+void CWeaponDODBaseGun::Precache()
+{
+	BaseClass::Precache();
+
+	// Precache all weapon ejections, since every weapon will appear in the game.
+	PrecacheModel( "models/shells/shell_small.mdl" );
+	PrecacheModel( "models/shells/shell_medium.mdl" );
+	PrecacheModel( "models/shells/shell_large.mdl" );
+	PrecacheModel( "models/shells/garand_clip.mdl" );
+}
+
+void CWeaponDODBaseGun::PrimaryAttack()
+{
+	Assert( m_pWeaponInfo );
+
+	DODBaseGunFire();
+}
+
+void CWeaponDODBaseGun::DODBaseGunSpawn( void )
+{
+	WEAPON_FILE_INFO_HANDLE	hWpnInfo = LookupWeaponInfoSlot( GetClassname() );
+
+	Assert( hWpnInfo != GetInvalidWeaponInfoHandle() );
+
+	CDODWeaponInfo *pWeaponInfo = dynamic_cast< CDODWeaponInfo* >( GetFileWeaponInfoFromHandle( hWpnInfo ) );
+
+	Assert( pWeaponInfo && "Failed to get CDODWeaponInfo in weapon spawn" );
+		
+	m_pWeaponInfo = pWeaponInfo;
+
+	BaseClass::Spawn();
+}
+
+float CWeaponDODBaseGun::GetWeaponAccuracy( float flPlayerSpeed )
+{
+	//snipers and deployable weapons inherit this and override when we need a different accuracy
+
+	float flSpread = m_pWeaponInfo->m_flAccuracy;
+
+	if( flPlayerSpeed > 45 )
+		flSpread += m_pWeaponInfo->m_flAccuracyMovePenalty;
+
+	return flSpread;
+}
+
+bool CWeaponDODBaseGun::DODBaseGunFire()
+{
+	CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+
+	Assert( pPlayer );
+	
+	// Out of ammo?
+	if ( m_iClip1 <= 0 )
+	{
+		if (m_bFireOnEmpty)
+		{
+			PlayEmptySound();
+			m_flNextPrimaryAttack = gpGlobals->curtime + 0.2;
+		}
+
+		return false;
+	}
+
+	if( pPlayer->GetWaterLevel() > 2 )
+	{
+		PlayEmptySound();
+		m_flNextPrimaryAttack = gpGlobals->curtime + 1.0;
+		return false;
+	}
+	
+	/* decrement before calling PlayPrimaryAttackAnim, so we can play the empty anim if necessary */
+	m_iClip1--;
+
+	SendWeaponAnim( GetPrimaryAttackActivity() );
+
+	// player "shoot" animation
+	pPlayer->SetAnimation( PLAYER_ATTACK1 );
+	
+	FX_FireBullets(
+		pPlayer->entindex(),
+		pPlayer->Weapon_ShootPosition(),
+		pPlayer->EyeAngles() + pPlayer->GetPunchAngle(),
+		GetWeaponID(),
+		Primary_Mode,
+		CBaseEntity::GetPredictionRandomSeed() & 255,
+		GetWeaponAccuracy( pPlayer->GetAbsVelocity().Length2D() ) );
+
+	DoFireEffects();
+
+#ifndef CLIENT_DLL
+	IGameEvent * event = gameeventmanager->CreateEvent( "dod_stats_weapon_attack" );
+	if ( event )
+	{
+		event->SetInt( "attacker", pPlayer->GetUserID() );
+		event->SetInt( "weapon", GetStatsWeaponID() );
+
+		gameeventmanager->FireEvent( event );
+	}
+#endif	//CLIENT_DLL
+
+#ifdef CLIENT_DLL
+	CDODPlayer *p = ToDODPlayer( GetPlayerOwner() );
+
+	if ( prediction->IsFirstTimePredicted() )
+		p->DoRecoil( GetWeaponID(), GetRecoil() );
+#endif
+
+	m_flNextPrimaryAttack = m_flNextSecondaryAttack = gpGlobals->curtime + GetFireDelay();
+
+	m_flTimeWeaponIdle = gpGlobals->curtime + m_pWeaponInfo->m_flTimeToIdleAfterFire;
+	return true;
+}
+
+float CWeaponDODBaseGun::GetFireDelay( void )
+{
+	return m_pWeaponInfo->m_flFireDelay;
+}
+
+void CWeaponDODBaseGun::DoFireEffects()
+{
+	CBasePlayer *pPlayer = GetPlayerOwner();
+	
+	if ( pPlayer )
+		 pPlayer->DoMuzzleFlash();
+}
+
+
+bool CWeaponDODBaseGun::Reload()
+{
+	CBasePlayer *pPlayer = GetPlayerOwner();
+
+	if (pPlayer->GetAmmoCount( GetPrimaryAmmoType() ) <= 0 && m_iClip1 <= 0 )
+	{
+		CDODPlayer *pDODPlayer = ToDODPlayer( pPlayer );
+		pDODPlayer->HintMessage( HINT_AMMO_EXHAUSTED );
+		return false;
+	}
+
+	int iResult = DefaultReload( GetMaxClip1(), GetMaxClip2(), GetReloadActivity() );
+	if ( !iResult )
+		return false;
+
+	pPlayer->SetAnimation( PLAYER_RELOAD );
+
+	return true;
+}
+
+Activity CWeaponDODBaseGun::GetPrimaryAttackActivity( void )
+{
+	return ACT_VM_PRIMARYATTACK;
+}
+
+Activity CWeaponDODBaseGun::GetReloadActivity( void )
+{
+	return ACT_VM_RELOAD;
+}
+
+Activity CWeaponDODBaseGun::GetDrawActivity( void )
+{
+	return ACT_VM_DRAW;
+}

game/shared/dod/weapon_dodbasegun.h

@@ -0,0 +1,83 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef WEAPON_DODBASE_GUN_H
+#define WEAPON_DODBASE_GUN_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "weapon_dodbase.h"
+
+// This is the base class for pistols and rifles.
+#if defined( CLIENT_DLL )
+
+	//#include "particles_simple.h"
+	//#include "particles_localspace.h"
+	#include "fx.h"
+	#include "fx_dod_muzzleflash.h"
+
+	#define CWeaponDODBaseGun C_WeaponDODBaseGun
+
+#else
+#endif
+
+class CWeaponDODBaseGun : public CWeaponDODBase
+{
+public:
+	
+	DECLARE_CLASS( CWeaponDODBaseGun, CWeaponDODBase );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CWeaponDODBaseGun();
+
+	virtual void Spawn();
+	virtual void Precache();
+	virtual void PrimaryAttack();
+	virtual bool Reload();
+
+	// Derived classes must call this from inside their Spawn() function instead of 
+	// just chaining the Spawn() call down.
+	void DODBaseGunSpawn( void );
+	
+	// Derived classes call this to fire a bullet.
+	bool DODBaseGunFire( void );
+
+	// Usually plays the shot sound. Guns with silencers can play different sounds.
+	virtual void DoFireEffects();
+	virtual float GetFireDelay( void );
+
+	virtual float GetWeaponAccuracy( float flPlayerSpeed );
+
+	//Pure animation calls - inheriting classes can override with specific
+	//logic, eg if the idle changes depending on the gun being empty or not
+	virtual Activity GetPrimaryAttackActivity( void );
+	virtual Activity GetReloadActivity( void );
+	virtual Activity GetDrawActivity( void );
+
+	virtual bool CanDrop( void ) { return m_pWeaponInfo->m_bCanDrop; }
+	
+	void SetZoomed( bool bZoomed ) { m_bZoomed = bZoomed; }
+	bool IsSniperZoomed( void ) { return m_bZoomed; }
+	CNetworkVar( bool, m_bZoomed );
+
+protected:
+	CDODWeaponInfo *m_pWeaponInfo;
+
+private:
+	CWeaponDODBaseGun( const CWeaponDODBaseGun & );
+
+#ifndef CLIENT_DLL
+
+	DECLARE_DATADESC();
+
+#endif
+};
+
+
+#endif // WEAPON_DODBASE_GUN_H

game/shared/dod/weapon_dodbasemelee.cpp

@@ -0,0 +1,237 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodbasemelee.h"
+#include "dod_gamerules.h"
+
+#if defined( CLIENT_DLL )
+	#include "c_dod_player.h"
+#else
+	#include "dod_player.h"
+	#include "ilagcompensationmanager.h"
+#endif
+
+#include "effect_dispatch_data.h"
+
+
+#define	KNIFE_BODYHIT_VOLUME 128
+#define	KNIFE_WALLHIT_VOLUME 512
+
+// ----------------------------------------------------------------------------- //
+// CWeaponDODBaseMelee tables.
+// ----------------------------------------------------------------------------- //
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponDODBaseMelee, DT_WeaponDODBaseMelee )
+
+BEGIN_NETWORK_TABLE_NOBASE( CWeaponDODBaseMelee, DT_LocalActiveWeaponBaseMeleeData )
+END_NETWORK_TABLE()
+
+BEGIN_NETWORK_TABLE( CWeaponDODBaseMelee, DT_WeaponDODBaseMelee )
+END_NETWORK_TABLE()
+
+#ifdef CLIENT_DLL
+BEGIN_PREDICTION_DATA( CWeaponDODBaseMelee )
+	DEFINE_PRED_FIELD( m_flSmackTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
+END_PREDICTION_DATA()
+#endif
+
+LINK_ENTITY_TO_CLASS( weapon_dod_base_melee, CWeaponDODBaseMelee );
+
+#ifndef CLIENT_DLL
+
+	BEGIN_DATADESC( CWeaponDODBaseMelee )
+		DEFINE_FUNCTION( Smack )
+	END_DATADESC()
+
+#endif
+
+// ----------------------------------------------------------------------------- //
+// CWeaponDODBaseMelee implementation.
+// ----------------------------------------------------------------------------- //
+
+CWeaponDODBaseMelee::CWeaponDODBaseMelee()
+{
+}
+
+void CWeaponDODBaseMelee::Spawn()
+{
+	Precache();
+
+	WEAPON_FILE_INFO_HANDLE	hWpnInfo = LookupWeaponInfoSlot( GetClassname() );
+
+	Assert( hWpnInfo != GetInvalidWeaponInfoHandle() );
+
+	CDODWeaponInfo *pWeaponInfo = dynamic_cast< CDODWeaponInfo* >( GetFileWeaponInfoFromHandle( hWpnInfo ) );
+
+	Assert( pWeaponInfo && "Failed to get CDODWeaponInfo in melee weapon spawn" );
+		
+	m_pWeaponInfo = pWeaponInfo;
+
+	Assert( m_pWeaponInfo );
+
+	m_iClip1 = -1;
+	BaseClass::Spawn();
+}
+
+void CWeaponDODBaseMelee::WeaponIdle( void )
+{
+	if ( m_flTimeWeaponIdle > gpGlobals->curtime )
+		return;
+
+	SendWeaponAnim( ACT_VM_IDLE );
+
+	m_flTimeWeaponIdle = gpGlobals->curtime + SequenceDuration();
+}
+
+void CWeaponDODBaseMelee::PrimaryAttack()
+{
+	MeleeAttack( 60, MELEE_DMG_EDGE, 0.2f, 0.4f );
+}
+
+CBaseEntity *CWeaponDODBaseMelee::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 ( 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;
+				}
+			}
+		}
+	}
+
+	bool bDidHit = ( tr.fraction < 1.0f );
+
+	bool bDoStrongAttack = false;
+
+	if ( bDidHit && tr.m_pEnt->IsPlayer() && tr.m_pEnt->m_takedamage != DAMAGE_YES )
+	{
+		bDidHit = 0;	// still play the animation, we just dont attempt to damage this player
+	}
+
+	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;
+
+		int iOwnerTeam = pPlayer->GetTeamNumber();
+		int iVictimTeam = tr.m_pEnt->GetTeamNumber();
+
+		// do the mega attack if its a player, and we would do damage
+		if ( tr.m_pEnt->IsPlayer() &&
+			tr.m_pEnt->m_takedamage == DAMAGE_YES && 
+			( iVictimTeam != iOwnerTeam || ( iVictimTeam == iOwnerTeam && friendlyfire.GetBool() ) ) )
+		{
+			CDODPlayer *pVictim = ToDODPlayer( tr.m_pEnt );
+
+			Vector victimForward;
+			AngleVectors( pVictim->GetAbsAngles(), &victimForward );
+
+			if ( DotProduct( victimForward, vForward ) > 0.3 )
+			{
+				bDoStrongAttack = true;
+			}
+		}
+	}
+
+	if ( bDoStrongAttack )
+	{
+		m_iSmackDamage = 300;
+		flAttackDelay = 0.9f;
+		m_flSmackTime = gpGlobals->curtime + 0.4f;
+
+		m_iSmackDamageType = MELEE_DMG_EDGE | MELEE_DMG_STRONGATTACK;
+
+		// play a "Strong" attack
+		SendWeaponAnim( ACT_VM_SECONDARYATTACK );
+	}
+	else
+	{
+		WeaponSound( MELEE_MISS );
+		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", GetStatsWeaponID() );
+
+		gameeventmanager->FireEvent( event );
+	}
+
+	lagcompensation->FinishLagCompensation( pPlayer );
+#endif	//CLIENT_DLL
+
+	return tr.m_pEnt;
+}

game/shared/dod/weapon_dodbasemelee.h

@@ -0,0 +1,57 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef WEAPON_DODBASE_MELEE_H
+#define WEAPON_DODBASE_MELEE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "weapon_dodbase.h"
+
+#if defined( CLIENT_DLL )
+	#define CWeaponDODBaseMelee C_WeaponDODBaseMelee
+#endif
+
+// ----------------------------------------------------------------------------- //
+// class definition.
+// ----------------------------------------------------------------------------- //
+
+class CWeaponDODBaseMelee : public CWeaponDODBase
+{
+public:
+	DECLARE_CLASS( CWeaponDODBaseMelee, CWeaponDODBase );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	#ifndef CLIENT_DLL
+		DECLARE_DATADESC();
+	#endif
+
+	CWeaponDODBaseMelee();
+
+	virtual void Spawn();
+	virtual void PrimaryAttack();
+	virtual void WeaponIdle();
+
+	virtual DODWeaponID GetWeaponID( void ) const { return WEAPON_NONE; }
+	virtual bool ShouldDrawCrosshair( void ) { return false; }
+	virtual bool HasPrimaryAmmo() { return true; }
+	virtual bool CanBeSelected() { return true; }
+
+	virtual CBaseEntity *MeleeAttack( int iDamageAmount, int iDamageType, float flDmgDelay, float flAttackDelay );
+
+	//virtual const char *GetSecondaryDeathNoticeName( void ) { return "stab"; }
+
+public:	
+	CDODWeaponInfo *m_pWeaponInfo;
+
+private:
+	CWeaponDODBaseMelee( const CWeaponDODBaseMelee & ) {}
+};
+
+
+#endif // WEAPON_DODBASE_MELEE_H

game/shared/dod/weapon_dodbaserpg.cpp

@@ -0,0 +1,345 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "dod_gamerules.h"
+#include "weapon_dodbaserpg.h"
+
+
+#ifdef CLIENT_DLL
+
+	#include "c_dod_player.h"
+	#include "prediction.h"
+
+#else
+
+	#include "dod_player.h"
+
+#endif
+
+IMPLEMENT_NETWORKCLASS_ALIASED( DODBaseRocketWeapon, DT_BaseRocketWeapon )
+
+BEGIN_NETWORK_TABLE( CDODBaseRocketWeapon, DT_BaseRocketWeapon )
+
+#ifdef CLIENT_DLL
+	RecvPropBool( RECVINFO(m_bDeployed) )
+#else
+	SendPropBool( SENDINFO(m_bDeployed) )
+#endif
+
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CDODBaseRocketWeapon )
+END_PREDICTION_DATA()
+
+#ifndef CLIENT_DLL
+
+BEGIN_DATADESC( CDODBaseRocketWeapon )
+END_DATADESC()
+
+#endif
+
+LINK_ENTITY_TO_CLASS( weapon_dodbaserpg, CDODBaseRocketWeapon );
+
+CDODBaseRocketWeapon::CDODBaseRocketWeapon()
+{
+}
+
+void CDODBaseRocketWeapon::Precache()
+{
+	BaseClass::Precache();
+}
+
+bool CDODBaseRocketWeapon::Reload( void )
+{
+	CDODPlayer *pPlayer = GetDODPlayerOwner();
+
+	if (pPlayer->GetAmmoCount( GetPrimaryAmmoType() ) <= 0)
+	{
+		CDODPlayer *pDODPlayer = ToDODPlayer( pPlayer );
+		pDODPlayer->HintMessage( HINT_AMMO_EXHAUSTED );
+		return false;
+	}
+
+	Activity actReload;
+
+	if( IsDeployed() )
+		actReload = ACT_VM_RELOAD_DEPLOYED;
+	else
+		actReload = ACT_VM_RELOAD;
+
+	int iResult = DefaultReload( GetMaxClip1(), GetMaxClip2(), actReload );
+	if ( !iResult )
+		return false;
+
+	pPlayer->SetAnimation( PLAYER_RELOAD );
+
+	// if we don't want the auto-rezoom, undeploy here
+	if ( !pPlayer->ShouldAutoRezoom() )
+	{
+		m_bDeployed = false;
+		pPlayer->SetBazookaDeployed( m_bDeployed );
+	}
+
+	return true;
+}
+
+bool CDODBaseRocketWeapon::ShouldPlayerBeSlow( void )
+{
+	if( IsDeployed() && !m_bInReload )
+	{
+		return true;
+	}
+	else
+		return false;
+}
+
+void CDODBaseRocketWeapon::Spawn( )
+{
+	WEAPON_FILE_INFO_HANDLE	hWpnInfo = LookupWeaponInfoSlot( GetClassname() );
+
+	Assert( hWpnInfo != GetInvalidWeaponInfoHandle() );
+
+	CDODWeaponInfo *pWeaponInfo = dynamic_cast< CDODWeaponInfo* >( GetFileWeaponInfoFromHandle( hWpnInfo ) );
+
+	Assert( pWeaponInfo && "Failed to get CDODWeaponInfo in weapon spawn" );
+		
+	m_pWeaponInfo = pWeaponInfo;
+
+	BaseClass::Spawn();
+}
+
+void CDODBaseRocketWeapon::Drop( const Vector &vecVelocity )
+{
+	SetDeployed( false );
+
+	BaseClass::Drop( vecVelocity );
+}
+
+bool CDODBaseRocketWeapon::Deploy( )
+{
+	return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), GetDrawActivity(), (char*)GetAnimPrefix() );
+}
+
+Activity CDODBaseRocketWeapon::GetDrawActivity( void )
+{
+	return ACT_VM_DRAW;
+}
+
+bool CDODBaseRocketWeapon::CanHolster( void )
+{
+	// can't holster if we are delpoyed and not reloading
+	if ( IsDeployed() && !m_bInReload )
+		return false;
+
+	return true;
+}
+
+bool CDODBaseRocketWeapon::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+#ifndef CLIENT_DLL
+
+	CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+	pPlayer->SetBazookaDeployed( false );
+
+#endif
+
+	SetDeployed( false );
+
+	return BaseClass::Holster(pSwitchingTo);
+}
+
+
+void CDODBaseRocketWeapon::PrimaryAttack()
+{
+	Assert( m_pWeaponInfo );
+
+	CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+	
+	// Out of ammo?
+	if ( m_iClip1 <= 0 )
+	{
+		if (m_bFireOnEmpty)
+		{
+			PlayEmptySound();
+			m_flNextPrimaryAttack = gpGlobals->curtime + 0.2;
+		}
+
+		return;
+	}
+
+	if( pPlayer->GetWaterLevel() > 2 )
+	{
+		PlayEmptySound();
+		m_flNextPrimaryAttack = gpGlobals->curtime + 1.0;
+		return;
+	}
+
+	if( IsDeployed() )
+	{
+		// player "shoot" animation
+		pPlayer->SetAnimation( PLAYER_ATTACK1 );
+
+		SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+		
+		FireRocket();
+
+		DoFireEffects();
+
+		m_iClip1--; 
+
+#ifdef CLIENT_DLL
+		if ( prediction->IsFirstTimePredicted() )
+			pPlayer->DoRecoil( GetWeaponID(), GetRecoil() );
+#endif
+
+		if ( m_iClip1 <= 0 && pPlayer->GetAmmoCount( GetPrimaryAmmoType() ) <= 0 )
+		{
+			Lower();
+		}
+
+		m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration() + 0.5;
+		m_flTimeWeaponIdle = gpGlobals->curtime + SequenceDuration() + 0.5;	//length of the fire anim!
+
+#ifndef CLIENT_DLL
+		IGameEvent * event = gameeventmanager->CreateEvent( "dod_stats_weapon_attack" );
+		if ( event )
+		{
+			event->SetInt( "attacker", pPlayer->GetUserID() );
+			event->SetInt( "weapon", GetStatsWeaponID() );
+
+			gameeventmanager->FireEvent( event );
+		}
+#endif	//CLIENT_DLL
+	}
+	else
+	{
+#ifdef CLIENT_DLL
+		pPlayer->HintMessage( HINT_SHOULDER_WEAPON, true );
+#endif
+
+		m_flNextPrimaryAttack = gpGlobals->curtime + 2.0f;
+	}
+}
+
+void CDODBaseRocketWeapon::FireRocket( void )
+{
+	Assert( !"Derived classes must implement this." );
+}
+
+void CDODBaseRocketWeapon::DoFireEffects()
+{
+	CBasePlayer *pPlayer = GetPlayerOwner();
+	
+	if ( pPlayer )
+		 pPlayer->DoMuzzleFlash();
+
+	//smoke etc
+}
+
+void CDODBaseRocketWeapon::SecondaryAttack()
+{
+	CBasePlayer *pPlayer = GetPlayerOwner();
+
+	//if we're underwater, lower it
+	if( pPlayer->GetWaterLevel() > 2 )
+	{
+		if( IsDeployed() )
+			Lower();
+		return;
+	}
+
+	if( IsDeployed() )
+	{	
+		Lower();
+	}
+	else
+	{
+		if ( CanAttack() )
+            Raise();
+	}	
+}
+
+void CDODBaseRocketWeapon::WeaponIdle()
+{
+	if (m_flTimeWeaponIdle > gpGlobals->curtime)
+		return;
+
+	SendWeaponAnim( GetIdleActivity() );
+
+	m_flTimeWeaponIdle = gpGlobals->curtime + SequenceDuration();
+}
+
+Activity CDODBaseRocketWeapon::GetIdleActivity( void )
+{
+	Activity actIdle;
+
+	if( IsDeployed() )
+		actIdle = ACT_VM_IDLE_DEPLOYED;
+	else
+		actIdle = ACT_VM_IDLE;
+
+	return actIdle;
+}
+
+/* Raise the Bazooka to your shoulder */
+void CDODBaseRocketWeapon::Raise()
+{
+	//raise to the shoulder
+	SendWeaponAnim( GetRaiseActivity() );
+
+	m_bDeployed = true;
+
+	m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration();
+	m_flNextSecondaryAttack = gpGlobals->curtime + SequenceDuration();
+	m_flTimeWeaponIdle = gpGlobals->curtime + SequenceDuration();
+}
+
+/* Lower the bazooka to running position */
+bool CDODBaseRocketWeapon::Lower()
+{
+	SendWeaponAnim( GetLowerActivity() );
+
+	m_bDeployed = false;
+	
+	CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+	pPlayer->SetBazookaDeployed( m_bDeployed );
+	
+	m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration();
+	m_flNextSecondaryAttack = gpGlobals->curtime + SequenceDuration();
+	m_flTimeWeaponIdle = gpGlobals->curtime + SequenceDuration();
+
+	return true;
+}
+
+Activity CDODBaseRocketWeapon::GetLowerActivity( void )
+{
+	return ACT_VM_UNDEPLOY;
+}
+
+Activity CDODBaseRocketWeapon::GetRaiseActivity( void )
+{
+	return ACT_VM_DEPLOY;
+}
+
+#ifdef CLIENT_DLL
+
+ConVar deployed_bazooka_sensitivity( "deployed_bazooka_sensitivity", "0.6", FCVAR_CHEAT, "Mouse sensitivity while deploying a bazooka" );
+
+void CDODBaseRocketWeapon::OverrideMouseInput( float *x, float *y )
+{
+	if( m_bDeployed )
+	{
+		float flSensitivity = deployed_bazooka_sensitivity.GetFloat();
+
+		*x *= flSensitivity;
+		*y *= flSensitivity;		
+	}
+}
+
+#endif

game/shared/dod/weapon_dodbaserpg.h

@@ -0,0 +1,88 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef WEAPON_DODBASERPG_H
+#define WEAPON_DODBASERPG_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "weapon_dodbase.h"
+ 
+
+#if defined( CLIENT_DLL )
+
+	#define CDODBaseRocketWeapon C_DODBaseRocketWeapon
+
+#endif
+
+//-----------------------------------------------------------------------------
+// RPG
+//-----------------------------------------------------------------------------
+class CDODBaseRocketWeapon : public CWeaponDODBase
+{
+public:
+	DECLARE_CLASS( CDODBaseRocketWeapon, CWeaponDODBase );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CDODBaseRocketWeapon();
+
+	virtual void Spawn();
+	virtual void PrimaryAttack();
+	virtual void SecondaryAttack();
+	virtual bool Deploy();
+	virtual bool CanHolster();
+	virtual bool Holster( CBaseCombatWeapon *pSwitchingTo = NULL );
+	virtual bool Reload();
+	virtual void WeaponIdle();
+	virtual void Drop( const Vector &vecVelocity );
+
+	virtual bool CanDrop( void ) { return ( IsDeployed() == false ); }
+
+	void		DoFireEffects();
+
+	void		Precache( void );
+
+	void		Raise();
+	bool		Lower();
+
+	virtual Activity GetDrawActivity( void );
+	virtual Activity GetIdleActivity( void );
+	virtual Activity GetLowerActivity( void );
+	virtual Activity GetRaiseActivity( void );
+
+	virtual	void FireRocket( void );
+
+	inline bool IsDeployed() { return m_bDeployed; }
+	inline void SetDeployed( bool bDeployed ) { m_bDeployed = bDeployed; }
+	
+	bool		ShouldPlayerBeSlow( void );
+
+	virtual bool ShouldAutoEjectBrass( void ) { return false; }
+
+#ifdef CLIENT_DLL
+	virtual void OverrideMouseInput( float *x, float *y );
+#endif
+
+	virtual float GetRecoil( void ) { return 10.0f; }
+
+protected:
+	CNetworkVar( bool, m_bDeployed );
+
+	CDODWeaponInfo *m_pWeaponInfo;
+
+private:
+	CDODBaseRocketWeapon( const CDODBaseRocketWeapon & );
+	
+#ifndef CLIENT_DLL
+	DECLARE_DATADESC();
+#endif
+};
+
+#endif // WEAPON_DODBASERPG_H

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

game/shared/dod/weapon_dodbipodgun.h

@@ -0,0 +1,92 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h" 
+#include "shake.h" 
+#include "weapon_dodfullauto.h"
+
+#if defined( CLIENT_DLL )
+	#define CDODBipodWeapon C_DODBipodWeapon
+#endif
+
+class CDODBipodWeapon : public CDODFullAutoWeapon
+{
+public:
+	DECLARE_CLASS( CDODBipodWeapon, CDODFullAutoWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+
+	CDODBipodWeapon();
+
+	virtual void Spawn();
+	virtual void Precache();
+	virtual void Drop( const Vector &vecVelocity );
+	virtual void SecondaryAttack( void );
+	virtual bool Reload( void );
+
+	virtual float GetWeaponAccuracy( float flPlayerSpeed );
+
+	virtual Activity GetUndeployActivity( void );
+	virtual Activity GetDeployActivity( void );
+	virtual Activity GetPrimaryAttackActivity( void );
+	virtual Activity GetReloadActivity( void );
+	virtual Activity GetIdleActivity( void );
+
+	virtual bool CanDrop( void );
+	virtual bool CanHolster( void );
+
+	inline void SetDeployed( bool bDeployed );
+	inline bool IsDeployed( void ) { return m_bDeployed; }
+
+	virtual void ItemBusyFrame( void );
+	virtual void ItemPostFrame( void );
+	void BipodThink( void );
+
+	bool AttemptToDeploy( void );
+	bool CheckDeployEnt( void );
+
+	bool TestDeploy( float *flDeployedHeight, CBaseEntity **pDeployedOn, float *flYawLimitLeft = NULL, float *flYawLimitRight = NULL );
+	bool TestDeployAngle( CDODPlayer *pPlayer, float *flDeployedHeight, CBaseEntity **pDeployedOn, QAngle angles );
+
+	bool FindYawLimits( float *flLeftLimit, float *flRightLimit );
+
+	virtual void DoFireEffects();
+
+	void DeployBipod( float flHeight, CBaseEntity *pDeployedOn, float flYawLimitLeft, float flYawLimitRight );
+	void UndeployBipod( void );
+
+	virtual DODWeaponID GetWeaponID( void ) const { return WEAPON_NONE; }
+
+#ifdef CLIENT_DLL
+	virtual int GetWorldModelIndex( void );
+	virtual void CheckForAltWeapon( int iCurrentState );
+
+	virtual void OverrideMouseInput( float *x, float *y );
+#endif
+
+private:
+	CDODBipodWeapon( const CDODBipodWeapon & );
+
+	CNetworkVar( bool, m_bDeployed );
+
+	CNetworkVar( int, m_iDeployedModelIndex );
+	CNetworkVar( int, m_iDeployedReloadModelIndex );
+	CNetworkVar( int, m_iProneDeployedReloadModelIndex );
+
+	int m_iCurrentWorldModel;
+
+	EHANDLE m_hDeployedOnEnt;
+	float m_flDeployedHeight;
+	float m_flNextDeployCheckTime;
+
+	Vector m_DeployedEntOrigin;
+
+	bool m_bDuckedWhenDeployed;
+
+#ifdef CLIENT_DLL
+	bool m_bUseDeployedReload;
+#endif
+};

game/shared/dod/weapon_dodfireselect.cpp

@@ -0,0 +1,211 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h" 
+#include "fx_dod_shared.h"
+#include "weapon_dodfireselect.h"
+
+#ifdef CLIENT_DLL
+	#include "prediction.h"
+#endif
+
+IMPLEMENT_NETWORKCLASS_ALIASED( DODFireSelectWeapon, DT_FireSelectWeapon )
+
+
+BEGIN_NETWORK_TABLE( CDODFireSelectWeapon, DT_FireSelectWeapon )
+#ifdef CLIENT_DLL	
+	RecvPropBool( RECVINFO( m_bSemiAuto ) )
+#else
+	SendPropBool( SENDINFO( m_bSemiAuto ) )
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CDODFireSelectWeapon )
+END_PREDICTION_DATA()
+
+
+CDODFireSelectWeapon::CDODFireSelectWeapon()
+{
+}
+
+void CDODFireSelectWeapon::Spawn( void )
+{
+	m_bSemiAuto = false;
+
+#ifdef CLIENT_DLL
+	ResetViewModelAnimDir();
+#endif
+
+	m_iAltFireHint = HINT_USE_SEMI_AUTO;
+
+	BaseClass::Spawn();
+}
+
+void CDODFireSelectWeapon::PrimaryAttack( void )
+{
+	if ( IsSemiAuto() )
+	{
+		// If semi auto, set this flag which will prevent us from
+		// attacking again until the button is released.
+		m_bInAttack = true;
+	}
+
+	BaseClass::PrimaryAttack();
+}
+
+float CDODFireSelectWeapon::GetFireDelay( void )
+{
+	if ( IsSemiAuto() )
+	{
+		return m_pWeaponInfo->m_flSecondaryFireDelay;
+	}
+	else
+	{
+		return m_pWeaponInfo->m_flFireDelay;
+	}	
+}
+
+void CDODFireSelectWeapon::SecondaryAttack( void )
+{
+	// toggle fire mode ( full auto, semi auto )
+	m_bSemiAuto = !m_bSemiAuto;
+
+#ifndef CLIENT_DLL
+	CDODPlayer *pPlayer = GetDODPlayerOwner();
+	if ( pPlayer )
+	{
+		pPlayer->RemoveHintTimer( m_iAltFireHint );
+	}
+#endif
+
+	if ( m_bSemiAuto )
+	{
+#ifdef CLIENT_DLL
+		if ( prediction->IsFirstTimePredicted() )
+		{
+			m_flPosChangeTimer = gpGlobals->curtime;
+			m_bAnimToSemiAuto = false;
+		}
+#endif
+
+		SendWeaponAnim( ACT_VM_UNDEPLOY );
+	}
+	else
+	{
+#ifdef CLIENT_DLL
+		if ( prediction->IsFirstTimePredicted() )
+		{
+			m_flPosChangeTimer = gpGlobals->curtime;
+			m_bAnimToSemiAuto = true;
+		}
+#endif
+
+		SendWeaponAnim( ACT_VM_DEPLOY );
+	}
+
+#ifdef CLIENT_DLL
+	if ( prediction->IsFirstTimePredicted() )
+	{
+		m_flPosChangeTimer = gpGlobals->curtime;
+	}
+#endif
+
+	m_flNextSecondaryAttack = gpGlobals->curtime + SequenceDuration();
+	m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration();
+}
+
+bool CDODFireSelectWeapon::IsSemiAuto( void )
+{
+	return m_bSemiAuto;
+}
+
+float CDODFireSelectWeapon::GetWeaponAccuracy( float flPlayerSpeed )
+{
+	float flSpread;
+	
+	if ( IsSemiAuto() )
+		flSpread = m_pWeaponInfo->m_flSecondaryAccuracy;
+	else
+		flSpread = m_pWeaponInfo->m_flAccuracy;
+
+	if( flPlayerSpeed > 45 )
+		flSpread += m_pWeaponInfo->m_flAccuracyMovePenalty;
+
+	return flSpread;
+}
+
+Activity CDODFireSelectWeapon::GetIdleActivity( void )
+{
+	if ( !IsSemiAuto() )
+		return ACT_VM_IDLE_DEPLOYED;
+
+	return BaseClass::GetIdleActivity();
+}
+
+Activity CDODFireSelectWeapon::GetPrimaryAttackActivity( void )
+{
+	if ( !IsSemiAuto() )
+		return ACT_VM_PRIMARYATTACK_DEPLOYED;
+
+	return BaseClass::GetPrimaryAttackActivity();
+}
+
+Activity CDODFireSelectWeapon::GetReloadActivity( void )
+{
+	if ( !IsSemiAuto() )
+		return ACT_VM_RELOAD_DEPLOYED;
+
+	return BaseClass::GetReloadActivity();
+}
+
+Activity CDODFireSelectWeapon::GetDrawActivity( void )
+{
+	if ( !IsSemiAuto() )
+		return ACT_VM_DRAW_DEPLOYED;
+
+	return BaseClass::GetDrawActivity();
+}
+
+void CDODFireSelectWeapon::Drop( const Vector &vecVelocity )
+{
+	// always full auto when you pick up a weapon
+	m_bSemiAuto = false;
+
+	return BaseClass::Drop( vecVelocity );
+}
+
+#ifdef CLIENT_DLL
+	Vector CDODFireSelectWeapon::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 );
+
+		Vector offset = ( flPercent * GetDODWpnData().m_vecViewNormalOffset +
+			( 1.0 - flPercent ) * GetDODWpnData().m_vecViewProneOffset );
+
+		static float flLastPercent = 0;
+
+		if ( prediction->InPrediction() )
+		{
+			return ( flLastPercent * offset +
+				( 1.0 - flLastPercent ) * GetDODWpnData().m_vecViewProneOffset );
+		}
+
+		float timer = gpGlobals->curtime - m_flPosChangeTimer;
+
+		// how long since we changed iron sight mode
+		float flPosChangePercent = clamp( ( timer / ( 0.3 ) ), 0.0, 1.0 );
+
+		float flZoomPercent = ( m_bAnimToSemiAuto ? ( 1.0 - flPosChangePercent ) : flPosChangePercent );
+
+		// store this value to use when called in prediction
+		flLastPercent = flZoomPercent;
+
+		return ( flZoomPercent * GetDODWpnData().m_vecIronSightOffset +
+			( 1.0 - flZoomPercent ) * offset );
+	}
+#endif

game/shared/dod/weapon_dodfireselect.h

@@ -0,0 +1,73 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef WEAPON_DODFIRESELECT_H
+#define WEAPON_DODFIRESELECT_H
+
+#include "cbase.h"
+#include "weapon_dodbasegun.h"
+
+#if defined( CLIENT_DLL )
+#define CDODFireSelectWeapon C_DODFireSelectWeapon
+
+#include "c_dod_player.h"
+#endif
+
+class CDODFireSelectWeapon : public CWeaponDODBaseGun
+{
+public:
+	DECLARE_CLASS( CDODFireSelectWeapon, CWeaponDODBaseGun );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+
+	CDODFireSelectWeapon();
+
+	virtual void Spawn();
+	virtual void PrimaryAttack( void );
+	virtual void SecondaryAttack( void );
+	virtual float GetWeaponAccuracy( float flPlayerSpeed );
+	virtual float GetFireDelay( void );
+	virtual void Drop( const Vector &vecVelocity );
+
+	bool IsSemiAuto( void );
+
+	virtual Activity GetIdleActivity( void );
+	virtual Activity GetPrimaryAttackActivity( void );
+	virtual Activity GetReloadActivity( void );
+	virtual Activity GetDrawActivity( void );
+
+#ifdef CLIENT_DLL
+	virtual Vector GetDesiredViewModelOffset( C_DODPlayer *pOwner );
+
+	void ResetViewModelAnimDir( void )
+	{
+		m_bAnimToSemiAuto = true;
+		m_flPosChangeTimer = 0;
+	}
+
+	virtual void OnWeaponDropped( void )
+	{
+		ResetViewModelAnimDir();
+
+		m_bSemiAuto = false;
+
+		BaseClass::OnWeaponDropped();
+	}
+#endif
+
+private:
+	CNetworkVar( bool, m_bSemiAuto );
+
+#ifdef CLIENT_DLL
+	bool m_bAnimToSemiAuto;
+	float m_flPosChangeTimer;
+#endif
+
+private:
+	CDODFireSelectWeapon( const CDODFireSelectWeapon & );
+};
+
+#endif //WEAPON_DODFIRESELECT_H

game/shared/dod/weapon_dodfullauto.cpp

@@ -0,0 +1,32 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h" 
+#include "fx_dod_shared.h"
+#include "weapon_dodfullauto.h"
+
+IMPLEMENT_NETWORKCLASS_ALIASED( DODFullAutoWeapon, DT_FullAutoWeapon )
+
+BEGIN_NETWORK_TABLE( CDODFullAutoWeapon, DT_FullAutoWeapon )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CDODFullAutoWeapon )
+END_PREDICTION_DATA()
+
+
+CDODFullAutoWeapon::CDODFullAutoWeapon()
+{
+}
+
+void CDODFullAutoWeapon::Spawn()
+{
+	BaseClass::Spawn();
+}
+
+void CDODFullAutoWeapon::PrimaryAttack( void )
+{
+	BaseClass::PrimaryAttack();
+}

game/shared/dod/weapon_dodfullauto.h

@@ -0,0 +1,36 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef WEAPON_DODFULLAUTO_H
+#define WEAPON_DODFULLAUTO_H
+
+#include "cbase.h" 
+#include "shake.h" 
+#include "weapon_dodbasegun.h"
+
+#if defined( CLIENT_DLL )
+	#define CDODFullAutoWeapon C_DODFullAutoWeapon
+#endif
+
+class CDODFullAutoWeapon : public CWeaponDODBaseGun
+{
+public:
+	DECLARE_CLASS( CDODFullAutoWeapon, CWeaponDODBaseGun );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+
+	CDODFullAutoWeapon();
+
+	virtual void Spawn();
+	virtual void PrimaryAttack( void );
+
+	virtual DODWeaponID GetWeaponID( void ) const { return WEAPON_NONE; }
+
+private:
+	CDODFullAutoWeapon( const CDODFullAutoWeapon & );
+};
+
+#endif //WEAPON_DODFULLAUTO_H

game/shared/dod/weapon_dodfullauto_punch.cpp

@@ -0,0 +1,84 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h" 
+#include "weapon_dodfullauto_punch.h"
+#include "in_buttons.h"
+#include "dod_shareddefs.h"
+
+#ifndef CLIENT_DLL
+#include "dod_player.h"
+#endif
+
+IMPLEMENT_NETWORKCLASS_ALIASED( DODFullAutoPunchWeapon, DT_FullAutoPunchWeapon )
+
+BEGIN_NETWORK_TABLE( CDODFullAutoPunchWeapon, DT_FullAutoPunchWeapon )
+END_NETWORK_TABLE()
+
+#ifdef CLIENT_DLL
+BEGIN_PREDICTION_DATA( CDODFullAutoPunchWeapon )
+END_PREDICTION_DATA()
+#endif
+
+void CDODFullAutoPunchWeapon::Spawn( void )
+{
+	m_iAltFireHint = HINT_USE_MELEE;
+
+	BaseClass::Spawn();
+}
+
+void CDODFullAutoPunchWeapon::SecondaryAttack( void )
+{
+	if ( m_bInReload )
+	{
+		m_bInReload = false;
+		GetPlayerOwner()->m_flNextAttack = gpGlobals->curtime;
+	}
+	else if ( GetPlayerOwner()->m_flNextAttack > gpGlobals->curtime )
+	{
+		return;
+	}
+
+	Punch();
+
+	// start calling ItemPostFrame
+	GetPlayerOwner()->m_flNextAttack = gpGlobals->curtime;
+
+	m_flNextPrimaryAttack = m_flNextSecondaryAttack;
+
+#ifndef CLIENT_DLL
+	CDODPlayer *pPlayer = GetDODPlayerOwner();
+	if ( pPlayer )
+	{
+		pPlayer->RemoveHintTimer( m_iAltFireHint );
+	}
+#endif
+}
+
+bool CDODFullAutoPunchWeapon::Reload( void )
+{
+	bool bSuccess = BaseClass::Reload();
+
+	if ( bSuccess )
+	{
+		m_flNextSecondaryAttack = gpGlobals->curtime;
+	}
+
+	return bSuccess;
+}
+
+void CDODFullAutoPunchWeapon::ItemBusyFrame( void )
+{
+	BaseClass::ItemBusyFrame();
+
+	CBasePlayer *pPlayer = GetPlayerOwner();
+
+	if ( pPlayer && (pPlayer->m_nButtons & IN_ATTACK2) && (m_flNextSecondaryAttack <= gpGlobals->curtime))
+	{
+		SecondaryAttack();
+		pPlayer->m_nButtons &= ~IN_ATTACK2;
+	}
+}

game/shared/dod/weapon_dodfullauto_punch.h

@@ -0,0 +1,34 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"  
+#include "weapon_dodfullauto.h"
+
+#if defined( CLIENT_DLL )
+	#define CDODFullAutoPunchWeapon C_DODFullAutoPunchWeapon
+#endif
+
+class CDODFullAutoPunchWeapon : public CDODFullAutoWeapon
+{
+public:
+	DECLARE_CLASS( CDODFullAutoPunchWeapon, CDODFullAutoWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+
+	CDODFullAutoPunchWeapon() {}
+
+	virtual void Spawn( void );
+	virtual void SecondaryAttack( void );
+	virtual bool Reload( void );
+	virtual void ItemBusyFrame( void );
+	
+	virtual const char *GetSecondaryDeathNoticeName( void ) { return "punch"; }
+
+	virtual DODWeaponID GetWeaponID( void ) const { return WEAPON_NONE; }
+
+private:
+	CDODFullAutoPunchWeapon( const CDODFullAutoPunchWeapon & );
+};

game/shared/dod/weapon_dodsemiauto.cpp

@@ -0,0 +1,37 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h" 
+#include "weapon_dodsemiauto.h"
+
+IMPLEMENT_NETWORKCLASS_ALIASED( DODSemiAutoWeapon, DT_SemiAutoWeapon )
+
+BEGIN_NETWORK_TABLE( CDODSemiAutoWeapon, DT_SemiAutoWeapon )
+END_NETWORK_TABLE()
+
+#ifdef CLIENT_DLL
+BEGIN_PREDICTION_DATA( CDODSemiAutoWeapon )
+END_PREDICTION_DATA()
+#endif
+
+CDODSemiAutoWeapon::CDODSemiAutoWeapon()
+{
+}
+
+void CDODSemiAutoWeapon::Spawn()
+{
+	BaseClass::Spawn();
+}
+
+void CDODSemiAutoWeapon::PrimaryAttack( void )
+{
+	//Don't attack more than once on the same button press.
+	//m_bInAttack is set to false when the attack button is released
+
+	m_bInAttack = true;
+
+	BaseClass::PrimaryAttack();
+}

game/shared/dod/weapon_dodsemiauto.h

@@ -0,0 +1,40 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef WEAPON_DODSEMIAUTO_H
+#define WEAPON_DODSEMIAUTO_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "cbase.h"  
+#include "shake.h" 
+#include "weapon_dodbasegun.h"
+
+
+#if defined( CLIENT_DLL )
+	#define CDODSemiAutoWeapon C_DODSemiAutoWeapon
+#endif
+
+class CDODSemiAutoWeapon : public CWeaponDODBaseGun
+{
+public:
+	DECLARE_CLASS( CDODSemiAutoWeapon, CWeaponDODBaseGun );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+
+	CDODSemiAutoWeapon();
+
+	virtual void Spawn();
+	virtual void PrimaryAttack( void );
+
+	virtual DODWeaponID GetWeaponID( void ) const { return WEAPON_NONE; }
+
+private:
+	CDODSemiAutoWeapon( const CDODSemiAutoWeapon & );
+};
+
+#endif //WEAPON_DODSEMIAUTO_H

game/shared/dod/weapon_dodsniper.cpp

@@ -0,0 +1,414 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h" 
+#include "fx_dod_shared.h"
+#include "weapon_dodsniper.h"
+
+#ifdef CLIENT_DLL
+	#include "prediction.h"
+#endif
+
+IMPLEMENT_NETWORKCLASS_ALIASED( DODSniperWeapon, DT_SniperWeapon )
+
+#ifdef CLIENT_DLL
+
+	void RecvProxy_AnimStart( const CRecvProxyData *pData, void *pStruct, void *pOut )
+	{
+		CDODSniperWeapon *pWpn = (CDODSniperWeapon *) pStruct;
+		pWpn->m_bDoViewAnim =  ( pData->m_Value.m_Int > 0 );
+	}
+
+#endif
+
+BEGIN_NETWORK_TABLE( CDODSniperWeapon, DT_SniperWeapon )
+	#ifdef CLIENT_DLL
+		RecvPropBool( RECVINFO( m_bZoomed ) ),
+		RecvPropInt( RECVINFO( m_bDoViewAnim ), 0, RecvProxy_AnimStart )
+	#else
+		SendPropBool( SENDINFO( m_bZoomed ) ),
+		SendPropBool( SENDINFO( m_bDoViewAnim ) )
+	#endif
+END_NETWORK_TABLE()
+
+
+#ifdef CLIENT_DLL
+
+	BEGIN_PREDICTION_DATA( CDODSniperWeapon )
+		DEFINE_PRED_FIELD( m_bZoomed, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE )
+	END_PREDICTION_DATA()
+
+#else
+
+	BEGIN_DATADESC( CDODSniperWeapon )
+	END_DATADESC()
+
+#endif
+
+
+CDODSniperWeapon::CDODSniperWeapon()
+{
+}
+
+void CDODSniperWeapon::Spawn( void )
+{
+	BaseClass::Spawn();
+
+	ResetTimers();
+
+#ifdef CLIENT_DLL
+	m_bDoViewAnimCache = false;
+	m_flZoomPercent = 0.0f;
+#endif
+
+	m_bShouldRezoomAfterShot = true;
+}
+
+void CDODSniperWeapon::ResetTimers( void )
+{
+	m_flUnzoomTime = -1;
+	m_flRezoomTime = -1;
+	m_flZoomOutTime = -1;
+	m_flZoomInTime = -1;
+	m_bRezoomAfterShot = false;
+	m_bRezoomAfterReload = false;
+}
+
+bool CDODSniperWeapon::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+#ifndef CLIENT_DLL
+	ZoomOut();	
+
+	ResetTimers();
+#endif
+
+	return BaseClass::Holster( pSwitchingTo );
+}
+
+void CDODSniperWeapon::PrimaryAttack( void )
+{
+	BaseClass::PrimaryAttack();
+
+	CDODPlayer *pPlayer = ToDODPlayer( GetOwner() );
+
+	if ( IsZoomed() && ShouldZoomOutBetweenShots() )
+	{
+		//If we have more bullets, zoom out, play the bolt animation and zoom back in
+		if( m_iClip1 > 0 && m_bShouldRezoomAfterShot && ( pPlayer && pPlayer->ShouldAutoRezoom() ) )
+		{
+			SetRezoom( true, 0.5f );	// zoom out in 0.5 seconds, then rezoom
+		}
+		else	//just zoom out
+		{
+			SetRezoom( false, 0.5f );	// just zoom out in 0.5 seconds
+		}
+	}
+
+	// overwrite the next secondary attack, so we can zoom sooned after we've fired
+	if ( m_bRezoomAfterShot && m_iClip1 > 0 )
+		m_flNextSecondaryAttack = gpGlobals->curtime + 2.0;
+	else
+		m_flNextSecondaryAttack = SequenceDuration();
+}
+
+void CDODSniperWeapon::SecondaryAttack( void )
+{
+	CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
+
+	Assert( pPlayer );
+
+	if ( !pPlayer )
+		return;
+
+	ToggleZoom();
+}
+
+bool CDODSniperWeapon::Reload( void )
+{
+	bool bSuccess = BaseClass::Reload();
+
+	if ( bSuccess && IsZoomed() )
+	{
+		//if ( ShouldRezoomAfterReload() )
+		//	m_bRezoomAfterReload = true;
+
+		ZoomOut();
+	}
+
+	if ( !bSuccess )
+		m_bRezoomAfterReload = false;
+
+	return bSuccess;
+}
+
+void CDODSniperWeapon::FinishReload( void )
+{
+	BaseClass::FinishReload();
+
+	if ( m_bRezoomAfterReload )
+	{
+		ZoomIn();
+		m_bRezoomAfterReload = false;
+	}
+}
+
+float CDODSniperWeapon::GetWeaponAccuracy( float flPlayerSpeed )
+{
+	//snipers and deployable weapons inherit this and override when we need a different accuracy
+
+	float flSpread = m_pWeaponInfo->m_flAccuracy;
+
+	if ( IsZoomed() && ( gpGlobals->curtime - m_flZoomChangeTime ) > DOD_SNIPER_ZOOM_CHANGE_TIME )
+	{
+		flSpread = m_pWeaponInfo->m_flSecondaryAccuracy;
+	}
+
+	if( flPlayerSpeed > 45 )
+		flSpread += m_pWeaponInfo->m_flAccuracyMovePenalty;
+
+	return flSpread;
+}
+
+bool CDODSniperWeapon::IsZoomed( void )
+{
+	// check the player?
+	return IsSniperZoomed();
+}
+
+bool CDODSniperWeapon::ShouldDrawCrosshair( void )
+{
+	//if ( IsFullyZoomed() )
+	//	return false;
+
+	// don't draw if we are zoomed at all
+	if ( m_bZoomed )
+		return false;
+
+	return BaseClass::ShouldDrawCrosshair();
+}
+
+#include "in_buttons.h"
+
+void CDODSniperWeapon::ItemPostFrame( void )
+{
+	if ( m_flUnzoomTime > 0 && gpGlobals->curtime > m_flUnzoomTime )
+	{
+		if ( m_bRezoomAfterShot )
+		{
+			ZoomOutIn();
+			m_bRezoomAfterShot = false;
+		}
+		else
+		{
+			ZoomOut();
+		}
+
+		m_flUnzoomTime = -1;
+	}
+
+	CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+	Assert( pPlayer );
+
+	if ( m_flRezoomTime > 0 )
+	{
+		// if the player is sprinting and moving at all, cancel the rezoom
+		if ( ( pPlayer->m_nButtons & IN_SPEED ) > 0 &&
+			pPlayer->GetAbsVelocity().Length2D() > 20 )
+		{
+			m_flRezoomTime = -1;
+		}
+		else if ( gpGlobals->curtime > m_flRezoomTime )
+		{
+            ZoomIn();
+			m_flRezoomTime = -1;
+		}
+	}
+
+	if ( m_flZoomInTime > 0 && gpGlobals->curtime > m_flZoomInTime )
+	{
+#ifndef CLIENT_DLL
+		CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+		Assert( pPlayer );
+		pPlayer->SetFOV( pPlayer, GetZoomedFOV(), 0.1f );
+#endif
+		m_flZoomInTime = -1;
+		m_flZoomOutTime = -1;
+	}
+
+	if ( m_flZoomInTime > 0 && (pPlayer->m_nButtons & IN_ATTACK) )
+	{
+		m_bInAttack = true;
+	}
+
+	BaseClass::ItemPostFrame();
+}
+
+void CDODSniperWeapon::Drop( const Vector &vecVelocity )
+{
+	// If a player is killed while deployed, this resets the weapon state
+	if ( IsZoomed() )
+		ZoomOut();
+
+	ResetTimers();
+
+	BaseClass::Drop( vecVelocity );
+}
+
+void CDODSniperWeapon::ToggleZoom( void )
+{
+	CDODPlayer *pPlayer = GetDODPlayerOwner();
+
+	if ( !pPlayer->m_Shared.IsJumping() )
+	{
+		if( !IsZoomed() )
+		{
+			if ( CanAttack() )
+			{
+#ifndef CLIENT_DLL
+				pPlayer->RemoveHintTimer( m_iAltFireHint );
+#endif
+
+				ZoomIn();
+			}
+		}
+		else
+		{
+			ZoomOut();
+		}
+	}	
+}
+
+void CDODSniperWeapon::ZoomIn( void )
+{
+	m_flZoomInTime = gpGlobals->curtime + DOD_SNIPER_ZOOM_CHANGE_TIME;
+
+#ifndef CLIENT_DLL
+	SetZoomed( true );
+
+	m_bDoViewAnim = !m_bDoViewAnim;
+#endif
+
+	m_flNextPrimaryAttack = MAX( gpGlobals->curtime + 0.5, m_flNextPrimaryAttack );
+	m_flNextSecondaryAttack = MAX( gpGlobals->curtime + 0.5, m_flNextSecondaryAttack );
+	m_flTimeWeaponIdle = gpGlobals->curtime + m_pWeaponInfo->m_flTimeToIdleAfterFire;
+
+	m_flZoomChangeTime = gpGlobals->curtime;
+}
+
+void CDODSniperWeapon::ZoomOut( void )
+{
+	bool bWasZoomed = IsZoomed();
+
+#ifndef CLIENT_DLL
+	CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+	Assert( pPlayer );
+
+	pPlayer->SetFOV( pPlayer, 90, 0.1f );
+	SetZoomed( false );
+
+	m_bDoViewAnim = !m_bDoViewAnim;
+#endif	
+
+	if ( bWasZoomed )
+	{
+		m_flNextPrimaryAttack = MAX( gpGlobals->curtime + 0.5, m_flNextPrimaryAttack );
+		m_flNextSecondaryAttack = MAX( gpGlobals->curtime + 0.5, m_flNextSecondaryAttack );
+		m_flTimeWeaponIdle = gpGlobals->curtime + m_pWeaponInfo->m_flTimeToIdleAfterFire;
+	}
+
+	m_flZoomChangeTime = gpGlobals->curtime;
+
+	// if we are thinking about zooming, cancel it
+	m_flZoomInTime = -1;
+	m_flUnzoomTime = -1;
+	m_flRezoomTime = -1;
+}
+
+// reduce rezoome time, to account for fade in we're replacing with anim
+#define REZOOM_TIME	1.2f
+
+void CDODSniperWeapon::ZoomOutIn( void )
+{
+	ZoomOut();
+
+	m_flRezoomTime = gpGlobals->curtime + 1.0;
+}
+
+void CDODSniperWeapon::SetRezoom( bool bRezoom, float flDelay )
+{
+	m_flUnzoomTime = gpGlobals->curtime + flDelay;
+
+	m_bRezoomAfterShot = bRezoom;
+}
+
+bool CDODSniperWeapon::IsFullyZoomed( void )
+{
+	return ( IsZoomed() == true &&
+		(( gpGlobals->curtime - m_flZoomChangeTime ) > DOD_SNIPER_ZOOM_CHANGE_TIME) );
+}
+
+bool CDODSniperWeapon::IsZoomingIn( void )
+{
+	return ( m_flZoomInTime > gpGlobals->curtime );
+}
+
+#ifdef CLIENT_DLL
+
+	float CDODSniperWeapon::GetZoomedPercentage( void )
+	{
+		return m_flZoomPercent;
+	}
+
+	Vector CDODSniperWeapon::GetDesiredViewModelOffset( C_DODPlayer *pOwner )
+	{
+		static Vector vecLastResult = vec3_origin;
+
+		if ( prediction->InPrediction() && !prediction->IsFirstTimePredicted() )
+		{
+			return vecLastResult;
+		}
+
+		if ( m_bDoViewAnim != m_bDoViewAnimCache )
+		{
+			// start the anim timer 
+			m_flViewAnimTimer = gpGlobals->curtime + DOD_SNIPER_ZOOM_CHANGE_TIME;
+			m_bDoViewAnimCache = m_bDoViewAnim.m_Value;
+		}
+
+		Vector viewOffset = pOwner->GetViewOffset();
+
+		float flPercent = clamp( ( viewOffset.z - VEC_PRONE_VIEW_SCALED( pOwner ).z ) / ( VEC_VIEW_SCALED( pOwner ).z - VEC_PRONE_VIEW_SCALED( pOwner ).z ), 0.0, 1.0 );
+
+		Vector offset = ( flPercent * GetDODWpnData().m_vecViewNormalOffset +
+			( 1.0 - flPercent ) * GetDODWpnData().m_vecViewProneOffset );
+
+		
+		// how long since we changed iron sight mode
+		float flZoomAnimPercent = clamp( ( (m_flViewAnimTimer - gpGlobals->curtime) / ( DOD_SNIPER_ZOOM_CHANGE_TIME ) ), 0.0, 1.0 );
+
+		m_flZoomPercent = ( IsZoomed() ? ( 1.0 - flZoomAnimPercent ) : flZoomAnimPercent );
+
+		//Msg( "(%.1f) zoom %.2f %.2f\n", gpGlobals->curtime, m_flViewAnimTimer - gpGlobals->curtime, m_flZoomPercent );
+
+		// use that percent to interp to iron sight position
+		Vector vecResult = ( m_flZoomPercent * GetDODWpnData().m_vecIronSightOffset + 
+			( 1.0 - m_flZoomPercent ) * offset );
+
+		// store this value to use when called in prediction
+		vecLastResult = vecResult;
+
+		return vecResult;
+	}
+
+	float CDODSniperWeapon::GetViewModelSwayScale( void )
+	{
+		if ( IsFullyZoomed() )
+			return 0;
+
+		return BaseClass::GetViewModelSwayScale();
+	}
+
+#endif	//CLIENT_DLL

game/shared/dod/weapon_dodsniper.h

@@ -0,0 +1,111 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef WEAPON_DODSNIPER_H
+#define WEAPON_DODSNIPER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "cbase.h" 
+#include "shake.h" 
+#include "weapon_dodsemiauto.h"
+#include "dod_shareddefs.h"
+
+#if defined( CLIENT_DLL )
+	#define CDODSniperWeapon C_DODSniperWeapon
+#endif
+
+#define DOD_SNIPER_ZOOM_CHANGE_TIME 0.3
+
+class CDODSniperWeapon : public CDODSemiAutoWeapon
+{
+public:
+	DECLARE_CLASS( CDODSniperWeapon, CDODSemiAutoWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+
+#ifndef CLIENT_DLL
+	DECLARE_DATADESC();
+#endif
+
+	CDODSniperWeapon();
+
+	virtual void Spawn( void );
+	virtual bool Holster( CBaseCombatWeapon *pSwitchingTo );
+	virtual bool Reload( void );
+	virtual void FinishReload( void );
+	virtual void Drop( const Vector &vecVelocity );
+	virtual void ItemPostFrame( void );
+
+	virtual void PrimaryAttack( void );
+	virtual void SecondaryAttack( void );
+
+	void ResetTimers( void );	// reset all the flags, timers that would cause us to re-zoom or unzoom
+
+#ifdef CLIENT_DLL
+	virtual Vector GetDesiredViewModelOffset( C_DODPlayer *pOwner );
+	virtual float GetViewModelSwayScale( void );
+
+	float GetZoomedPercentage( void );
+#endif
+
+	// Is the weapon completely zoomed, finished the raising animation
+	bool IsFullyZoomed( void );
+	
+	virtual bool ShouldDrawCrosshair( void );
+
+	virtual bool HideViewModelWhenZoomed( void ) { return true; }
+
+	virtual float GetWeaponAccuracy( float flPlayerSpeed );
+
+	virtual float GetZoomedFOV( void ) { return 20; }
+
+	bool IsZoomed( void );
+
+	virtual bool ShouldZoomOutBetweenShots( void ) { return true; }
+	virtual bool ShouldRezoomAfterReload( void ) { return false; }
+
+	void ToggleZoom( void );
+
+	void ZoomIn( void );
+	void ZoomOut( void );
+
+	void ZoomOutIn( void );
+
+	void SetRezoom( bool bRezoom, float flDelay );
+
+	bool IsZoomingIn( void );
+
+	CNetworkVar( bool, m_bDoViewAnim );
+
+
+
+#ifdef CLIENT_DLL
+	bool m_bDoViewAnimCache;
+	float m_flViewAnimTimer;
+	float m_flZoomPercent;
+#endif
+
+protected:
+	bool m_bShouldRezoomAfterShot;	// if the gun zooms out after a shot, does it zoom back in automatically?
+
+private:
+	CDODSniperWeapon( const CDODSniperWeapon & );
+
+	float m_flUnzoomTime;
+	float m_flRezoomTime;
+
+	float m_flZoomInTime;
+	float m_flZoomOutTime;	 
+
+	bool m_bRezoomAfterReload;
+	float m_flZoomChangeTime;
+	bool m_bRezoomAfterShot;
+};
+
+#endif // WEAPON_DODSNIPER_H

game/shared/dod/weapon_explodinghandgrenade.cpp

@@ -0,0 +1,52 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodbasegrenade.h"
+
+#ifdef CLIENT_DLL
+	#define CWeaponExplodingHandGrenade C_WeaponExplodingHandGrenade
+#else 
+	#include "dod_handgrenade.h"	//the thing that we throw
+#endif
+
+
+class CWeaponExplodingHandGrenade : public CWeaponDODBaseGrenade
+{
+public:
+	DECLARE_CLASS( CWeaponExplodingHandGrenade, CWeaponDODBaseGrenade );
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponExplodingHandGrenade() {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_FRAG_US_LIVE; }
+
+#ifndef CLIENT_DLL
+
+	virtual void EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer, float flLifeTime = GRENADE_FUSE_LENGTH )
+	{
+		CDODHandGrenade::Create( vecSrc, vecAngles, vecVel, angImpulse, pPlayer, flLifeTime, GetWeaponID() );
+	}
+
+#endif
+
+	virtual bool IsArmed( void ) { return true; }
+
+private:
+	CWeaponExplodingHandGrenade( const CWeaponExplodingHandGrenade & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponExplodingHandGrenade, DT_WeaponExplodingHandGrenade )
+
+BEGIN_NETWORK_TABLE(CWeaponExplodingHandGrenade, DT_WeaponExplodingHandGrenade)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponExplodingHandGrenade )	//MATTTODO: are these necessary?
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_frag_us_live, CWeaponExplodingHandGrenade );
+PRECACHE_WEAPON_REGISTER( weapon_frag_us_live );

game/shared/dod/weapon_explodingstickgrenade.cpp

@@ -0,0 +1,54 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodbasegrenade.h"
+
+#ifdef CLIENT_DLL
+	#define CWeaponExplodingStickGrenade C_WeaponExplodingStickGrenade
+#else
+	#include "dod_stickgrenade.h"	//the thing that we throw
+#endif
+
+class CWeaponExplodingStickGrenade : public CWeaponDODBaseGrenade
+{
+public:
+	DECLARE_CLASS( CWeaponExplodingStickGrenade, CWeaponDODBaseGrenade );
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponExplodingStickGrenade() {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_FRAG_GER_LIVE; }
+
+#ifndef CLIENT_DLL
+
+	virtual void EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer, float flLifeTime = GRENADE_FUSE_LENGTH )
+	{
+		// align the stickgrenade vertically and spin end over end
+		QAngle vecNewAngles = QAngle(45,pPlayer->EyeAngles().y,0);
+		AngularImpulse angNewImpulse = AngularImpulse( 0, 600, 0 );
+
+		CDODStickGrenade::Create( vecSrc, vecNewAngles, vecVel, angNewImpulse, pPlayer, flLifeTime, GetWeaponID() );
+	}
+
+#endif
+
+	virtual bool IsArmed( void ) { return true; }
+
+	CWeaponExplodingStickGrenade( const CWeaponExplodingStickGrenade & ) {}
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponExplodingStickGrenade, DT_WeaponExplodingStickGrenade )
+
+BEGIN_NETWORK_TABLE(CWeaponExplodingStickGrenade, DT_WeaponExplodingStickGrenade)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponExplodingStickGrenade )	//MATTTODO: are these necessary?
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_frag_ger_live, CWeaponExplodingStickGrenade );
+PRECACHE_WEAPON_REGISTER( weapon_frag_ger_live );

game/shared/dod/weapon_garand.cpp

@@ -0,0 +1,203 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodsniper.h"
+#include "dod_shareddefs.h"
+
+#ifndef CLIENT_DLL
+	#include "te_effect_dispatch.h"
+	#include "effect_dispatch_data.h"
+#endif
+
+#if defined( CLIENT_DLL )
+	#define CWeaponGarand C_WeaponGarand
+
+	#include "c_dod_player.h"
+#endif
+
+
+class CWeaponGarand : public CDODSniperWeapon
+{
+public:
+	DECLARE_CLASS( CWeaponGarand, CDODSniperWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+	
+	CWeaponGarand()  {}
+
+	virtual void	Spawn( void );
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_GARAND; }
+
+	// weapon id for stats purposes
+	virtual DODWeaponID GetStatsWeaponID( void )
+	{
+		if ( IsFullyZoomed() )
+            return WEAPON_GARAND_ZOOMED;
+		else 
+			return WEAPON_GARAND;
+	}
+
+	virtual Activity GetIdleActivity( void );
+	virtual Activity GetPrimaryAttackActivity( void );
+	virtual Activity GetDrawActivity( void );
+
+	virtual void PrimaryAttack( void );
+	virtual bool Reload( void );
+
+	virtual float GetZoomedFOV( void ) { return 55; }
+
+	virtual bool HideViewModelWhenZoomed( void ) { return false; }
+
+	virtual bool ShouldZoomOutBetweenShots( void ) { return false; }
+	virtual bool ShouldRezoomAfterReload( void ) { return true; }
+
+	virtual float GetRecoil( void ) { return 4.0f; }
+
+private:
+	CWeaponGarand( const CWeaponGarand & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponGarand, DT_WeaponGarand )
+
+BEGIN_NETWORK_TABLE( CWeaponGarand, DT_WeaponGarand )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponGarand )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_garand, CWeaponGarand );
+PRECACHE_WEAPON_REGISTER( weapon_garand );
+
+void CWeaponGarand::Spawn( void )
+{
+	m_iAltFireHint = HINT_USE_IRON_SIGHTS;
+
+	BaseClass::Spawn();
+}
+
+acttable_t CWeaponGarand::m_acttable[] = 
+{
+	{ ACT_DOD_STAND_AIM,					ACT_DOD_STAND_AIM_RIFLE,				false },
+	{ ACT_DOD_CROUCH_AIM,					ACT_DOD_CROUCH_AIM_RIFLE,				false },
+	{ ACT_DOD_CROUCHWALK_AIM,				ACT_DOD_CROUCHWALK_AIM_RIFLE,			false },
+	{ ACT_DOD_WALK_AIM,						ACT_DOD_WALK_AIM_RIFLE,					false },
+	{ ACT_DOD_RUN_AIM,						ACT_DOD_RUN_AIM_RIFLE,					false },
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_RIFLE,				false },
+	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_IDLE_RIFLE,			false },
+	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_IDLE_RIFLE,				false },
+	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_IDLE_RIFLE,				false },
+	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_IDLE_RIFLE,			false },
+	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_IDLE_RIFLE,				false },
+	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_IDLE_RIFLE,					false },
+	{ ACT_SPRINT,							ACT_DOD_SPRINT_IDLE_RIFLE,				false },
+
+	// Zoomed Aim
+	{ ACT_DOD_IDLE_ZOOMED,					ACT_DOD_STAND_ZOOM_RIFLE,				false },
+	{ ACT_DOD_CROUCH_ZOOMED,				ACT_DOD_CROUCH_ZOOM_RIFLE,				false },
+	{ ACT_DOD_CROUCHWALK_ZOOMED,			ACT_DOD_CROUCHWALK_ZOOM_RIFLE,			false },
+	{ ACT_DOD_WALK_ZOOMED,					ACT_DOD_WALK_ZOOM_RIFLE,				false },
+	{ ACT_DOD_PRONE_ZOOMED,					ACT_DOD_PRONE_ZOOM_RIFLE,				false },
+	{ ACT_DOD_PRONE_FORWARD_ZOOMED,			ACT_DOD_PRONE_ZOOM_FORWARD_RIFLE,		false },
+
+	// Attack ( prone? deployed? )
+	{ ACT_RANGE_ATTACK1,					ACT_DOD_PRIMARYATTACK_RIFLE,			false },
+	{ ACT_DOD_PRIMARYATTACK_CROUCH,			ACT_DOD_PRIMARYATTACK_RIFLE,			false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE,			ACT_DOD_PRIMARYATTACK_PRONE_RIFLE,		false },
+
+	{ ACT_RELOAD,							ACT_DOD_RELOAD_RIFLE,					false },
+	{ ACT_DOD_RELOAD_CROUCH,				ACT_DOD_RELOAD_CROUCH_RIFLE,			false },
+	{ ACT_DOD_RELOAD_PRONE,					ACT_DOD_RELOAD_PRONE_RIFLE,				false },
+
+	// Hand Signals
+	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_K98,					false },
+	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_K98,					false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponGarand );
+
+Activity CWeaponGarand::GetIdleActivity( void )
+{
+	Activity actIdle;
+
+	if( m_iClip1 <= 0 )
+		actIdle = ACT_VM_IDLE_EMPTY;	
+	else
+		actIdle = ACT_VM_IDLE;
+
+	return actIdle;
+}
+
+Activity CWeaponGarand::GetPrimaryAttackActivity( void )
+{
+	Activity actPrim;
+
+	if ( IsFullyZoomed() )
+		actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED;
+	else if( m_iClip1 <= 0 )
+		actPrim = ACT_VM_PRIMARYATTACK_EMPTY;	
+	else
+		actPrim = ACT_VM_PRIMARYATTACK;
+
+	return actPrim;
+}
+
+Activity CWeaponGarand::GetDrawActivity( void )
+{
+	Activity actDraw;
+
+	if( m_iClip1 <= 0 )
+		actDraw = ACT_VM_DRAW_EMPTY;	
+	else
+		actDraw = ACT_VM_DRAW;
+
+	return actDraw;
+}
+
+void CWeaponGarand::PrimaryAttack( void )
+{
+	int clip = m_iClip1;
+
+	BaseClass::PrimaryAttack();
+
+	// If we just fired our last bullet
+	if( clip != m_iClip1 && m_iClip1 == 0 )
+	{
+		// clip "DING!"
+		WeaponSound( SPECIAL1 );
+
+#ifndef CLIENT_DLL
+		CEffectData data;
+		data.m_nHitBox = EJECTBRASS_GARANDCLIP;
+		GetPlayerOwner()->GetAttachment( 2, data.m_vOrigin, data.m_vAngles  );
+	
+		// shoot it up in the air
+		data.m_vAngles.x = -90;
+		data.m_vAngles.y = 0;
+		data.m_vAngles.z = 0;
+
+		DispatchEffect( "DOD_EjectBrass", data );
+#endif
+	}
+}
+
+bool CWeaponGarand::Reload( void )
+{
+	if( m_iClip1 > 0 )
+	{
+#ifdef CLIENT_DLL
+		CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+		Assert( pPlayer );
+		pPlayer->HintMessage( HINT_GARAND_RELOAD, true );
+#endif
+		return false;
+	}
+
+	return BaseClass::Reload();
+}
+

game/shared/dod/weapon_gerknife.cpp

@@ -0,0 +1,56 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodbasemelee.h"
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponGerKnife C_WeaponGerKnife
+
+#endif
+
+
+class CWeaponGerKnife : public CWeaponDODBaseMelee
+{
+public:
+	DECLARE_CLASS( CWeaponGerKnife, CWeaponDODBaseMelee );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+	
+	CWeaponGerKnife()  {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_GERKNIFE; }
+
+private:
+	CWeaponGerKnife( const CWeaponGerKnife & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponGerKnife, DT_WeaponGerKnife )
+
+BEGIN_NETWORK_TABLE( CWeaponGerKnife, DT_WeaponGerKnife )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponGerKnife )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_gerknife, CWeaponGerKnife );
+PRECACHE_WEAPON_REGISTER( weapon_gerknife );
+
+acttable_t CWeaponGerKnife::m_acttable[] = 
+{
+	{ ACT_IDLE,								ACT_DOD_STAND_AIM_KNIFE,				false },
+	{ ACT_CROUCHIDLE,						ACT_DOD_CROUCH_AIM_KNIFE,				false },
+	{ ACT_RUN_CROUCH,						ACT_DOD_CROUCHWALK_AIM_KNIFE,			false },
+	{ ACT_WALK,								ACT_DOD_WALK_AIM_KNIFE,					false },
+	{ ACT_RUN,								ACT_DOD_RUN_AIM_KNIFE,					false },
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_KNIFE,				false },
+	{ ACT_RANGE_ATTACK1,					ACT_DOD_PRIMARYATTACK_KNIFE,			false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE,			ACT_DOD_PRIMARYATTACK_PRONE_KNIFE,		false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponGerKnife );

game/shared/dod/weapon_greasegun.cpp

@@ -0,0 +1,64 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodfullauto.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponGreaseGun C_WeaponGreaseGun
+
+#endif
+
+
+class CWeaponGreaseGun : public CDODFullAutoWeapon
+{
+public:
+	DECLARE_CLASS( CWeaponGreaseGun, CDODFullAutoWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+	
+	CWeaponGreaseGun()  {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_GREASEGUN; }
+
+private:
+	CWeaponGreaseGun( const CWeaponGreaseGun & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponGreaseGun, DT_WeaponGreaseGun )
+
+BEGIN_NETWORK_TABLE( CWeaponGreaseGun, DT_WeaponGreaseGun )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponGreaseGun )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_greasegun, CWeaponGreaseGun );
+PRECACHE_WEAPON_REGISTER( weapon_greasegun );
+
+acttable_t CWeaponGreaseGun::m_acttable[] = 
+{
+	// Aim
+	{ ACT_IDLE,								ACT_DOD_STAND_AIM_GREASE,				false },
+	{ ACT_CROUCHIDLE,						ACT_DOD_CROUCH_AIM_GREASE,				false },
+	{ ACT_RUN_CROUCH,						ACT_DOD_CROUCHWALK_AIM_GREASE,			false },
+	{ ACT_WALK,								ACT_DOD_WALK_AIM_GREASE,				false },
+	{ ACT_RUN,								ACT_DOD_RUN_AIM_GREASE,					false },
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_GREASE,				false },
+
+	// Attack ( prone? )
+	{ ACT_RANGE_ATTACK1,					ACT_DOD_PRIMARYATTACK_GREASE,			false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE,			ACT_DOD_PRIMARYATTACK_PRONE_GREASE,		false },
+
+	// Reload ( prone? )
+	{ ACT_RELOAD,							ACT_DOD_RELOAD_GREASEGUN,				false },
+	{ ACT_DOD_RELOAD_PRONE,					ACT_DOD_RELOAD_PRONE_GREASEGUN,			false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponGreaseGun );

game/shared/dod/weapon_handgrenade.cpp

@@ -0,0 +1,49 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodbasegrenade.h"
+
+#ifdef CLIENT_DLL
+	#define CWeaponHandGrenade C_WeaponHandGrenade
+#else
+	#include "dod_handgrenade.h"	//the thing that we throw
+#endif
+
+class CWeaponHandGrenade : public CWeaponDODBaseGrenade
+{
+public:
+	DECLARE_CLASS( CWeaponHandGrenade, CWeaponDODBaseGrenade );
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponHandGrenade() {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_FRAG_US; }
+
+#ifndef CLIENT_DLL
+
+	virtual void EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer, float flLifeTime = GRENADE_FUSE_LENGTH )
+	{
+		CDODHandGrenade::Create( vecSrc, vecAngles, vecVel, angImpulse, pPlayer, flLifeTime, GetWeaponID() );
+	}
+
+#endif
+
+private:
+	CWeaponHandGrenade( const CWeaponHandGrenade & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponHandGrenade, DT_WeaponHandGrenade )
+
+BEGIN_NETWORK_TABLE(CWeaponHandGrenade, DT_WeaponHandGrenade)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponHandGrenade )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_frag_us, CWeaponHandGrenade );
+PRECACHE_WEAPON_REGISTER( weapon_frag_us );

game/shared/dod/weapon_k98.cpp

@@ -0,0 +1,140 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodsniper.h"
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponK98 C_WeaponK98
+
+#endif
+
+
+class CWeaponK98 : public CDODSniperWeapon
+{
+public:
+	DECLARE_CLASS( CWeaponK98, CDODSniperWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+	
+	CWeaponK98()  {}
+
+	virtual void	Spawn( void );
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_K98; }
+
+	// weapon id for stats purposes
+	virtual DODWeaponID GetStatsWeaponID( void )
+	{
+		if ( IsFullyZoomed() )
+			return WEAPON_K98_ZOOMED;
+		else 
+			return WEAPON_K98;
+	}
+
+	virtual bool ShouldAutoEjectBrass( void ) { return false; }
+
+	virtual float GetZoomedFOV( void ) { return 55; }
+
+	virtual bool HideViewModelWhenZoomed( void ) { return false; }
+
+	virtual bool ShouldRezoomAfterReload( void ) { return true; }
+
+	virtual Activity GetPrimaryAttackActivity( void );
+
+	virtual float GetFireDelay( void );
+
+	virtual float GetRecoil( void ) { return 8.0f; }
+
+private:
+	CWeaponK98( const CWeaponK98 & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponK98, DT_WeaponK98 )
+
+BEGIN_NETWORK_TABLE( CWeaponK98, DT_WeaponK98 )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponK98 )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_k98, CWeaponK98 );
+PRECACHE_WEAPON_REGISTER( weapon_k98 );
+
+void CWeaponK98::Spawn( void )
+{
+	m_iAltFireHint = HINT_USE_IRON_SIGHTS;
+
+	BaseClass::Spawn();
+
+	m_bShouldRezoomAfterShot = false;
+}
+
+acttable_t CWeaponK98::m_acttable[] = 
+{
+	{ ACT_DOD_STAND_AIM,					ACT_DOD_STAND_AIM_BOLT,					false },
+	{ ACT_DOD_CROUCH_AIM,					ACT_DOD_CROUCH_AIM_BOLT,				false },
+	{ ACT_DOD_CROUCHWALK_AIM,				ACT_DOD_CROUCHWALK_AIM_BOLT,			false },
+	{ ACT_DOD_WALK_AIM,						ACT_DOD_WALK_AIM_BOLT,					false },
+	{ ACT_DOD_RUN_AIM,						ACT_DOD_RUN_AIM_BOLT,					false },
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_BOLT,					false },
+	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_IDLE_BOLT,			false },
+	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_IDLE_BOLT,				false },
+	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_IDLE_BOLT,				false },
+	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_IDLE_BOLT,			false },
+	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_IDLE_BOLT,					false },
+	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_IDLE_BOLT,					false },
+	{ ACT_SPRINT,							ACT_DOD_SPRINT_IDLE_BOLT,				false },
+
+	// Zoomed Aim
+	{ ACT_DOD_IDLE_ZOOMED,					ACT_DOD_STAND_ZOOM_BOLT,				false },
+	{ ACT_DOD_CROUCH_ZOOMED,				ACT_DOD_CROUCH_ZOOM_BOLT,				false },
+	{ ACT_DOD_CROUCHWALK_ZOOMED,			ACT_DOD_CROUCHWALK_ZOOM_BOLT,			false },
+	{ ACT_DOD_WALK_ZOOMED,					ACT_DOD_WALK_ZOOM_BOLT,					false },
+	{ ACT_DOD_PRONE_ZOOMED,					ACT_DOD_PRONE_ZOOM_BOLT,				false },
+	{ ACT_DOD_PRONE_FORWARD_ZOOMED,			ACT_DOD_PRONE_ZOOM_FORWARD_BOLT,		false },
+
+	// Attack ( prone? )
+	{ ACT_RANGE_ATTACK1,					ACT_DOD_PRIMARYATTACK_BOLT,				false },
+	{ ACT_DOD_PRIMARYATTACK_CROUCH,			ACT_DOD_PRIMARYATTACK_BOLT,				false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE,			ACT_DOD_PRIMARYATTACK_PRONE_BOLT,		false },
+
+	// Reload ( prone ? )
+	{ ACT_RELOAD,							ACT_DOD_RELOAD_BOLT,					false },
+	{ ACT_DOD_RELOAD_CROUCH,				ACT_DOD_RELOAD_CROUCH_BOLT,				false },
+	{ ACT_DOD_RELOAD_PRONE,					ACT_DOD_RELOAD_PRONE_BOLT,				false },
+
+	// Hand Signals
+	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_K98,					false },
+	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_K98,					false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponK98 );
+
+Activity CWeaponK98::GetPrimaryAttackActivity( void )
+{
+	Activity actPrim;
+
+	if( m_iClip1 <= 0 )
+		actPrim = ACT_VM_PRIMARYATTACK_EMPTY;	
+	else
+		actPrim = ACT_VM_PRIMARYATTACK;
+
+	return actPrim;
+}
+
+float CWeaponK98::GetFireDelay( void )
+{
+	if ( m_iClip1 <= 0 )
+	{
+		return SequenceDuration();
+	}
+
+	return BaseClass::GetFireDelay();
+}
+

game/shared/dod/weapon_k98_scoped.cpp

@@ -0,0 +1,156 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodsniper.h"
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponK98Scoped C_WeaponK98Scoped
+
+#endif
+
+
+class CWeaponK98Scoped : public CDODSniperWeapon
+{
+public:
+	DECLARE_CLASS( CWeaponK98Scoped, CDODSniperWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+	
+	CWeaponK98Scoped()  {}
+
+	virtual void Spawn( void );
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_K98_SCOPED; }
+
+	// weapon id for stats purposes
+	virtual DODWeaponID GetStatsWeaponID( void )
+	{
+		if ( IsFullyZoomed() )
+			return WEAPON_K98_SCOPED_ZOOMED;
+		else 
+			return WEAPON_K98_SCOPED;
+	}
+
+	virtual bool ShouldAutoEjectBrass( void ) { return false; }
+	virtual bool ShouldDrawCrosshair( void ) { return false; }
+
+	virtual bool ShouldDrawViewModel( void )
+	{
+		CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
+
+		Assert( pPlayer );
+
+		if ( !pPlayer )
+			return false;
+
+		if ( pPlayer->GetFOV() < 90 )
+			return false;
+
+		// handle case when we are spectating someone and don't know their fov
+		if ( IsFullyZoomed() )
+			return false;
+
+		return BaseClass::ShouldDrawViewModel();
+	}
+
+	virtual bool ShouldDrawMuzzleFlash( void )
+	{
+		return ShouldDrawViewModel();
+	}
+
+	virtual Activity GetPrimaryAttackActivity( void	);
+
+	virtual float GetFireDelay( void );
+
+	virtual float GetRecoil( void ) { return 6.0f; }
+
+private:
+	CWeaponK98Scoped( const CWeaponK98Scoped & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponK98Scoped, DT_WeaponK98Scoped )
+
+BEGIN_NETWORK_TABLE( CWeaponK98Scoped, DT_WeaponK98Scoped )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponK98Scoped )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_k98_scoped, CWeaponK98Scoped );
+PRECACHE_WEAPON_REGISTER( weapon_k98_scoped );
+
+void CWeaponK98Scoped::Spawn( void )
+{
+	m_iAltFireHint = HINT_USE_ZOOM;
+
+	BaseClass::Spawn();
+}
+
+acttable_t CWeaponK98Scoped::m_acttable[] = 
+{
+	{ ACT_DOD_STAND_AIM,					ACT_DOD_STAND_AIM_BOLT,					false },
+	{ ACT_DOD_CROUCH_AIM,					ACT_DOD_CROUCH_AIM_BOLT,				false },
+	{ ACT_DOD_CROUCHWALK_AIM,				ACT_DOD_CROUCHWALK_AIM_BOLT,			false },
+	{ ACT_DOD_WALK_AIM,						ACT_DOD_WALK_AIM_BOLT,					false },
+	{ ACT_DOD_RUN_AIM,						ACT_DOD_RUN_AIM_BOLT,					false },
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_BOLT,					false },
+	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_IDLE_BOLT,			false },
+	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_IDLE_BOLT,				false },
+	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_IDLE_BOLT,				false },
+	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_IDLE_BOLT,			false },
+	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_IDLE_BOLT,					false },
+	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_IDLE_BOLT,					false },
+	{ ACT_SPRINT,							ACT_DOD_SPRINT_IDLE_BOLT,				false },
+
+	// Zoomed Aim
+	{ ACT_DOD_IDLE_ZOOMED,					ACT_DOD_STAND_ZOOM_BOLT,				false },
+	{ ACT_DOD_CROUCH_ZOOMED,				ACT_DOD_CROUCH_ZOOM_BOLT,				false },
+	{ ACT_DOD_CROUCHWALK_ZOOMED,			ACT_DOD_CROUCHWALK_ZOOM_BOLT,			false },
+	{ ACT_DOD_WALK_ZOOMED,					ACT_DOD_WALK_ZOOM_BOLT,					false },
+	{ ACT_DOD_PRONE_ZOOMED,					ACT_DOD_PRONE_ZOOM_BOLT,				false },
+	{ ACT_DOD_PRONE_FORWARD_ZOOMED,			ACT_DOD_PRONE_ZOOM_FORWARD_BOLT,		false },
+
+	// Attack ( prone? )
+	{ ACT_RANGE_ATTACK1,					ACT_DOD_PRIMARYATTACK_BOLT,				false },
+	{ ACT_DOD_PRIMARYATTACK_CROUCH,			ACT_DOD_PRIMARYATTACK_BOLT,				false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE,			ACT_DOD_PRIMARYATTACK_PRONE_BOLT,		false },
+
+	// Reload ( prone ? )
+	{ ACT_RELOAD,							ACT_DOD_RELOAD_BOLT,					false },
+	{ ACT_DOD_RELOAD_CROUCH,				ACT_DOD_RELOAD_CROUCH_BOLT,				false },
+	{ ACT_DOD_RELOAD_PRONE,					ACT_DOD_RELOAD_PRONE_BOLT,				false },
+
+	// Hand Signals
+	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_K98,					false },
+	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_K98,					false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponK98Scoped );
+
+Activity CWeaponK98Scoped::GetPrimaryAttackActivity( void )
+{
+	Activity actPrim;
+
+	if( m_iClip1 <= 0 )
+		actPrim = ACT_VM_PRIMARYATTACK_EMPTY;	
+	else
+		actPrim = ACT_VM_PRIMARYATTACK;
+
+	return actPrim;
+}
+
+float CWeaponK98Scoped::GetFireDelay( void )
+{
+	if ( m_iClip1 <= 0 )
+	{
+		return SequenceDuration();
+	}
+
+	return BaseClass::GetFireDelay();
+}

game/shared/dod/weapon_m1carbine.cpp

@@ -0,0 +1,76 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodsemiauto.h"
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponM1Carbine C_WeaponM1Carbine
+
+#endif
+
+
+class CWeaponM1Carbine : public CDODSemiAutoWeapon
+{
+public:
+	DECLARE_CLASS( CWeaponM1Carbine, CDODSemiAutoWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+	
+	CWeaponM1Carbine()  {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_M1CARBINE; }
+
+	virtual float GetRecoil( void ) { return 1.4f; }
+
+private:
+	CWeaponM1Carbine( const CWeaponM1Carbine & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponM1Carbine, DT_WeaponM1Carbine )
+
+BEGIN_NETWORK_TABLE( CWeaponM1Carbine, DT_WeaponM1Carbine )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponM1Carbine )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_m1carbine, CWeaponM1Carbine );
+PRECACHE_WEAPON_REGISTER( weapon_m1carbine );
+
+acttable_t CWeaponM1Carbine::m_acttable[] = 
+{
+	{ ACT_DOD_STAND_AIM,					ACT_DOD_STAND_AIM_RIFLE,				false },
+	{ ACT_DOD_CROUCH_AIM,					ACT_DOD_CROUCH_AIM_RIFLE,				false },
+	{ ACT_DOD_CROUCHWALK_AIM,				ACT_DOD_CROUCHWALK_AIM_RIFLE,			false },
+	{ ACT_DOD_WALK_AIM,						ACT_DOD_WALK_AIM_RIFLE,					false },
+	{ ACT_DOD_RUN_AIM,						ACT_DOD_RUN_AIM_RIFLE,					false },
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_RIFLE,				false },
+	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_IDLE_RIFLE,			false },
+	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_IDLE_RIFLE,				false },
+	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_IDLE_RIFLE,				false },
+	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_IDLE_RIFLE,			false },
+	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_IDLE_RIFLE,				false },
+	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_IDLE_RIFLE,					false },
+	{ ACT_SPRINT,							ACT_DOD_SPRINT_IDLE_RIFLE,				false },
+
+	// Attack ( prone? )
+	{ ACT_RANGE_ATTACK1,					ACT_DOD_PRIMARYATTACK_RIFLE,			false },
+	{ ACT_DOD_PRIMARYATTACK_CROUCH,			ACT_DOD_PRIMARYATTACK_RIFLE,			false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE,			ACT_DOD_PRIMARYATTACK_PRONE_RIFLE,		false },
+
+	{ ACT_RELOAD,							ACT_DOD_RELOAD_M1CARBINE,				false },
+	{ ACT_DOD_RELOAD_CROUCH,				ACT_DOD_RELOAD_CROUCH_M1CARBINE,		false },
+	{ ACT_DOD_RELOAD_PRONE,					ACT_DOD_RELOAD_PRONE_M1CARBINE,			false },
+
+	// Hand Signals
+	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_K98,					false },
+	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_K98,					false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponM1Carbine );

game/shared/dod/weapon_mg34.cpp

@@ -0,0 +1,207 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodbipodgun.h"
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponMG34 C_WeaponMG34
+	#include "c_dod_player.h"
+
+#else
+
+	#include "dod_player.h"
+#endif
+
+
+class CWeaponMG34 : public CDODBipodWeapon
+{
+public:
+	DECLARE_CLASS( CWeaponMG34, CDODBipodWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+	
+	CWeaponMG34()  {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_MG34; }
+
+	virtual void PrimaryAttack( void );
+	virtual bool Reload( void );
+
+	Activity GetReloadActivity( void );
+	Activity GetDrawActivity( void );
+	Activity GetDeployActivity( void );
+	Activity GetUndeployActivity( void );
+	Activity GetIdleActivity( void );
+	Activity GetPrimaryAttackActivity( void );
+
+	virtual bool ShouldDrawCrosshair( void ) { return IsDeployed(); }
+
+private:
+	CWeaponMG34( const CWeaponMG34 & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponMG34, DT_WeaponMG34 )
+
+BEGIN_NETWORK_TABLE( CWeaponMG34, DT_WeaponMG34 )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponMG34 )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_mg34, CWeaponMG34 );
+PRECACHE_WEAPON_REGISTER( weapon_mg34 );
+
+acttable_t CWeaponMG34::m_acttable[] = 
+{
+	// Aim
+	{ ACT_IDLE,								ACT_DOD_STAND_AIM_MG,					false },
+	{ ACT_CROUCHIDLE,						ACT_DOD_CROUCH_AIM_MG,					false },
+	{ ACT_RUN_CROUCH,						ACT_DOD_CROUCHWALK_AIM_MG,				false },
+	{ ACT_WALK,								ACT_DOD_WALK_AIM_MG,					false },
+	{ ACT_RUN,								ACT_DOD_RUN_AIM_MG,						false },
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_MG,					false },
+
+	// Deployed Aim
+	{ ACT_DOD_DEPLOYED,						ACT_DOD_DEPLOY_MG,						false },
+	{ ACT_DOD_PRONE_DEPLOYED,				ACT_DOD_PRONE_DEPLOY_MG,				false },
+
+	// Attack ( prone? deployed? )
+	{ ACT_RANGE_ATTACK1,					ACT_DOD_PRIMARYATTACK_MG,				false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE,			ACT_DOD_PRIMARYATTACK_PRONE_MG,			false },
+	{ ACT_DOD_PRIMARYATTACK_DEPLOYED,		ACT_DOD_PRIMARYATTACK_DEPLOYED_MG,		false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE_DEPLOYED,	ACT_DOD_PRIMARYATTACK_PRONE_DEPLOYED_MG,false },
+
+	// Reload ( prone? deployed? )	
+	{ ACT_DOD_RELOAD_DEPLOYED,				ACT_DOD_RELOAD_DEPLOYED_MG34,			false },
+	{ ACT_DOD_RELOAD_PRONE_DEPLOYED,		ACT_DOD_RELOAD_PRONE_DEPLOYED_MG34,		false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponMG34 );
+
+void CWeaponMG34::PrimaryAttack( void )
+{
+#ifdef CLIENT_DLL
+	C_DODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+#else
+	CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+#endif
+
+	Assert( pPlayer );
+
+	if( !IsDeployed() )
+	{
+#ifdef CLIENT_DLL 
+		pPlayer->HintMessage( HINT_MG_FIRE_UNDEPLOYED );
+#endif
+		pPlayer->m_Shared.SetSlowedTime( 0.2 );
+
+		float flStamina = pPlayer->m_Shared.GetStamina();
+
+		pPlayer->m_Shared.SetStamina( flStamina - 15 );
+	}
+
+	BaseClass::PrimaryAttack();
+}
+
+bool CWeaponMG34::Reload( void )
+{
+	if( !IsDeployed() )
+	{
+		ClientPrint( GetPlayerOwner(), HUD_PRINTCENTER, "#Dod_mg_reload" );
+		return false;
+	}
+
+	return BaseClass::Reload();
+}
+
+Activity CWeaponMG34::GetReloadActivity( void )
+{
+	return ACT_VM_RELOAD;
+}
+
+Activity CWeaponMG34::GetDrawActivity( void )
+{
+	Activity actDraw;
+
+	if( m_iClip1 <= 0 )
+		actDraw = ACT_VM_DRAW_EMPTY;	
+	else
+		actDraw = ACT_VM_DRAW;
+
+	return actDraw;
+}
+
+Activity CWeaponMG34::GetDeployActivity( void )
+{
+	Activity actDeploy;
+
+	if( m_iClip1 <= 0 )
+		actDeploy = ACT_VM_DEPLOY_EMPTY;	
+	else
+		actDeploy = ACT_VM_DEPLOY;
+
+	return actDeploy;
+}
+
+Activity CWeaponMG34::GetUndeployActivity( void )
+{
+	Activity actUndeploy;
+
+	if( m_iClip1 <= 0 )
+		actUndeploy = ACT_VM_UNDEPLOY_EMPTY;	
+	else
+		actUndeploy = ACT_VM_UNDEPLOY;
+
+	return actUndeploy;
+}
+
+Activity CWeaponMG34::GetIdleActivity( void )
+{
+	Activity actIdle;
+
+	if( IsDeployed() )
+	{
+		if( m_iClip1 <= 0 )
+			actIdle = ACT_VM_IDLE_DEPLOYED_EMPTY;	
+		else
+			actIdle = ACT_VM_IDLE_DEPLOYED;
+	}
+	else
+	{
+		if( m_iClip1 <= 0 )
+			actIdle = ACT_VM_IDLE_EMPTY;	
+		else
+			actIdle = ACT_VM_IDLE;
+	}
+
+	return actIdle;
+}
+
+Activity CWeaponMG34::GetPrimaryAttackActivity( void )
+{
+	Activity actPrim;
+
+	if( IsDeployed() )
+	{
+		if( m_iClip1 <= 0 )
+			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_EMPTY;	
+		else
+			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED;
+	}
+	else
+	{
+		if( m_iClip1 <= 0 )
+			actPrim = ACT_VM_PRIMARYATTACK_EMPTY;	
+		else
+			actPrim = ACT_VM_PRIMARYATTACK;
+	}
+
+	return actPrim;
+}
+

game/shared/dod/weapon_mg42.cpp

@@ -0,0 +1,843 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_mg42.h"
+#include "engine/ivdebugoverlay.h"
+
+#if defined( CLIENT_DLL )
+
+	#include "tier1/KeyValues.h"
+	#include "particles_simple.h"
+	#include "particles_localspace.h"
+	#include "fx.h"
+	#include "c_dod_player.h"
+
+#else
+	
+	#include "dod_player.h"
+
+#endif
+
+
+#ifdef CLIENT_DLL	
+void ToolFramework_PostToolMessage( HTOOLHANDLE hEntity, KeyValues *msg );
+#endif
+
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponMG42, DT_WeaponMG42 )
+
+#ifdef GAME_DLL
+
+BEGIN_DATADESC( CWeaponMG42 )
+	DEFINE_THINKFUNC( CoolThink ),
+END_DATADESC()
+
+#endif
+
+BEGIN_NETWORK_TABLE( CWeaponMG42, DT_WeaponMG42 )
+#ifdef CLIENT_DLL	
+	RecvPropInt			( RECVINFO( m_iWeaponHeat ) ),
+	RecvPropTime		( RECVINFO( m_flNextCoolTime ) ),
+	RecvPropBool		( RECVINFO( m_bOverheated ) ),
+#else
+	SendPropInt			( SENDINFO( m_iWeaponHeat ), 7, SPROP_UNSIGNED ),
+	SendPropFloat		( SENDINFO( m_flNextCoolTime ) ),
+	SendPropBool		( SENDINFO( m_bOverheated ) ),
+#endif
+END_NETWORK_TABLE()
+
+#ifdef CLIENT_DLL
+BEGIN_PREDICTION_DATA( CWeaponMG42 )
+	DEFINE_PRED_FIELD( m_iWeaponHeat, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD_TOL( m_flNextCoolTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
+	DEFINE_PRED_FIELD( m_bOverheated, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+END_PREDICTION_DATA()
+#endif
+
+LINK_ENTITY_TO_CLASS( weapon_mg42, CWeaponMG42 );
+PRECACHE_WEAPON_REGISTER( weapon_mg42 );
+
+acttable_t CWeaponMG42::m_acttable[] = 
+{
+	{ ACT_DOD_STAND_AIM,					ACT_DOD_STAND_AIM_MG,				false },
+	{ ACT_DOD_CROUCH_AIM,					ACT_DOD_CROUCH_AIM_MG,				false },
+	{ ACT_DOD_CROUCHWALK_AIM,				ACT_DOD_CROUCHWALK_AIM_MG,			false },
+	{ ACT_DOD_WALK_AIM,						ACT_DOD_WALK_AIM_MG,				false },
+	{ ACT_DOD_RUN_AIM,						ACT_DOD_RUN_AIM_MG,					false },
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_MG,				false },
+	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_IDLE_MG,			false },
+	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_IDLE_MG,				false },
+	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_IDLE_MG,				false },
+	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_IDLE_MG,			false },
+	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_IDLE_MG,				false },
+	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_IDLE_MG,				false },
+	{ ACT_SPRINT,							ACT_DOD_SPRINT_IDLE_MG,				false },
+
+	// Deployed Aim
+	{ ACT_DOD_DEPLOYED,						ACT_DOD_DEPLOY_MG,						false },
+	{ ACT_DOD_PRONE_DEPLOYED,				ACT_DOD_PRONE_DEPLOY_MG,				false },
+
+	// Attack ( prone? deployed? )
+	{ ACT_RANGE_ATTACK1,					ACT_DOD_PRIMARYATTACK_MG,				false },
+	{ ACT_DOD_PRIMARYATTACK_CROUCH,			ACT_DOD_PRIMARYATTACK_MG,				false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE,			ACT_DOD_PRIMARYATTACK_PRONE_MG,			false },
+	{ ACT_DOD_PRIMARYATTACK_DEPLOYED,		ACT_DOD_PRIMARYATTACK_DEPLOYED_MG,		false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE_DEPLOYED,	ACT_DOD_PRIMARYATTACK_PRONE_DEPLOYED_MG,false },
+
+	// Reload ( prone? deployed? )	
+	{ ACT_DOD_RELOAD_DEPLOYED,				ACT_DOD_RELOAD_DEPLOYED_MG,				false },
+	{ ACT_DOD_RELOAD_PRONE_DEPLOYED,		ACT_DOD_RELOAD_PRONE_DEPLOYED_MG,		false },
+
+	// Hand Signals
+	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_MG42,					false },
+	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_MG42,					false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponMG42 );
+
+void CWeaponMG42::Spawn( void )
+{
+	m_iWeaponHeat = 0;
+	m_flNextCoolTime = 0;
+
+	m_bOverheated = false;
+
+#ifdef CLIENT_DLL
+	m_pEmitter = NULL;
+	m_flParticleAccumulator = 0.0;
+	m_hParticleMaterial = ParticleMgr()->GetPMaterial( "sprites/effects/bazookapuff" );
+#endif	
+
+	BaseClass::Spawn();
+}
+
+#ifdef CLIENT_DLL
+
+	CWeaponMG42::~CWeaponMG42()
+	{
+		if ( clienttools->IsInRecordingMode() && m_pEmitter.IsValid() && m_pEmitter->GetToolParticleEffectId() != TOOLPARTICLESYSTEMID_INVALID )
+		{
+			KeyValues *msg = new KeyValues( "ParticleSystem_ActivateEmitter" );
+			msg->SetInt( "id", m_pEmitter->GetToolParticleEffectId() );
+			msg->SetFloat( "time", gpGlobals->curtime );
+			msg->SetInt( "active", 0 );
+
+			msg->SetInt( "emitter", 0 );
+			ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );
+
+			msg->SetInt( "emitter", 1 );
+			ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );
+
+			msg->SetInt( "emitter", 2 );
+			ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );
+
+			msg->SetInt( "emitter", 3 );
+			ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );
+
+			msg->deleteThis();
+		}
+	}
+
+	void CWeaponMG42::OnDataChanged( DataUpdateType_t updateType )
+	{
+		BaseClass::OnDataChanged( updateType );
+
+		// BUG! This can happen more than once!
+		if ( updateType == DATA_UPDATE_CREATED )
+		{
+			if ( !m_pEmitter.IsValid() )
+			{
+				m_pEmitter = CSimpleEmitter::Create( "MGOverheat" );
+			}
+
+			Assert( m_pEmitter.IsValid() );
+		}
+
+		ClientThinkList()->SetNextClientThink( GetClientHandle(), CLIENT_THINK_ALWAYS );
+	}
+
+	// Client Think emits smoke particles based on heat
+	// ( except if we are holstered )
+	void CWeaponMG42::ClientThink( void )
+	{
+		m_pEmitter->SetSortOrigin( GetAbsOrigin() );
+
+		float flEmitRate = 0.0;	//particles per second
+
+		// Only smoke if we are dropped ( no owner ) or if we have an owner and are active
+		if ( GetOwner() == NULL || GetOwner()->GetActiveWeapon() == this )
+		{
+			if ( m_iWeaponHeat > 85 )
+			{	
+				flEmitRate = 30;
+			}
+			else if ( m_iWeaponHeat > 80 )
+			{
+				flEmitRate = 20;
+			}
+			else if ( m_iWeaponHeat > 65 )
+			{
+				flEmitRate = 10;
+			}
+			else if ( m_iWeaponHeat > 50 )
+			{
+				flEmitRate = 5;
+			}
+		}
+
+		m_flParticleAccumulator += ( gpGlobals->frametime * flEmitRate );
+
+		while( m_flParticleAccumulator > 0.0 )
+		{
+			EmitSmokeParticle();
+
+			m_flParticleAccumulator -= 1.0;
+		}
+	}
+
+	void CWeaponMG42::EmitSmokeParticle( void )
+	{
+		Vector vFront, vBack;	
+		QAngle angles;
+
+		C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
+
+		bool bViewModel = false;
+
+		// if this is locally owned
+		if ( GetPlayerOwner() == pLocalPlayer )
+		{
+			C_BaseViewModel *vm = pLocalPlayer->GetViewModel( 0 );
+
+			if ( !vm )
+				return;
+
+			vm->GetAttachment( 1, vFront, angles );
+			vm->GetAttachment( 2, vBack, angles );
+
+			bViewModel = true;
+		}
+		else
+		{
+			// could be dropped, or held by another player
+			GetAttachment( 1, vFront, angles );
+			GetAttachment( 2, vBack, angles );
+		}
+
+		// Get a position somewhere on the barrel
+		Vector vPos = vBack + random->RandomFloat(0.0, 1.0 ) * ( vFront - vBack );
+
+		SimpleParticle *pParticle = m_pEmitter->AddSimpleParticle( m_hParticleMaterial, vPos );
+		if ( pParticle )
+		{
+			pParticle->m_vecVelocity = Vector( 0,0,12 );
+			pParticle->m_flRoll = random->RandomFloat( 0, 0.5 );
+			pParticle->m_flRollDelta = ( random->RandomInt(0,1) == 0 ? 1 : -1 ) * random->RandomFloat( 0.5, 1.0 );
+			pParticle->m_flDieTime = 1.8f;
+			pParticle->m_flLifetime = 0;
+			pParticle->m_uchColor[0] = 200;
+			pParticle->m_uchColor[1] = 200; 
+			pParticle->m_uchColor[2] = 200;
+			pParticle->m_uchStartAlpha = 60;
+			pParticle->m_uchEndAlpha = 0;
+			pParticle->m_uchStartSize = 4;
+			pParticle->m_uchEndSize = 25;
+			pParticle->m_iFlags = 0;	//bViewModel ? FLE_VIEWMODEL : 0;
+		}
+	}
+
+#else
+
+	// This function does the cooling when the weapon is dropped or holstered
+	// regular, predicted cooling is done in ItemPostFrame
+	void CWeaponMG42::CoolThink( void )
+	{
+		if ( m_iWeaponHeat > 0 )
+			m_iWeaponHeat--;
+		
+		SetContextThink( &CWeaponMG42::CoolThink, gpGlobals->curtime + 0.1, COOL_CONTEXT );
+	}
+
+#endif	
+
+void CWeaponMG42::Precache()
+{
+	PrecacheMaterial( "sprites/effects/bazookapuff" );
+
+	PrecacheScriptSound( "Weapon_Mg42.OverHeat" );
+
+	BaseClass::Precache();
+}
+
+bool CWeaponMG42::Reload( void )
+{
+	if( !IsDeployed() )
+	{
+#ifdef CLIENT_DLL
+		CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+
+		if ( pPlayer )
+			pPlayer->HintMessage( HINT_MG_DEPLOY_TO_RELOAD );
+#endif
+		return false;
+	}
+
+	return BaseClass::Reload();
+}
+
+void CWeaponMG42::FinishReload( void )
+{
+	BaseClass::FinishReload();
+
+	//Reset the heat when you complete a reload
+	m_iWeaponHeat = 0;
+}
+
+void CWeaponMG42::PrimaryAttack( void )
+{
+	if( m_bOverheated )
+	{
+		return;
+	}
+
+	if ( m_iClip1 <= 0 )
+	{
+		if (m_bFireOnEmpty)
+		{
+			PlayEmptySound();
+			m_flNextPrimaryAttack = gpGlobals->curtime + 0.2;
+		}
+
+		return;
+	}
+
+
+	CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+	Assert( pPlayer );
+
+	if( m_iWeaponHeat >= 99 )
+	{
+		//can't fire anymore, wait until heat is below 80
+#ifdef CLIENT_DLL 
+		pPlayer->HintMessage( HINT_WEAPON_OVERHEAT );
+#endif
+		m_bOverheated = true;
+		m_bInAttack = true;
+
+		EmitSound( "Weapon_Mg42.OverHeat" );
+		return;
+	}
+
+	m_iWeaponHeat += 1; //2;
+	m_flNextCoolTime = gpGlobals->curtime + 0.16f;
+	
+	if( !IsDeployed() )
+	{
+#ifdef CLIENT_DLL 
+		pPlayer->HintMessage( HINT_MG_FIRE_UNDEPLOYED );
+#endif
+		pPlayer->m_Shared.SetSlowedTime( 0.2 );
+
+		float flStamina = pPlayer->m_Shared.GetStamina();
+
+		pPlayer->m_Shared.SetStamina( flStamina - 15 );
+	}
+
+	BaseClass::PrimaryAttack();
+}
+
+void CWeaponMG42::ItemPostFrame( void )
+{
+	ItemFrameCool();
+
+	if( m_iWeaponHeat < 80 )
+		m_bOverheated = false;	
+
+	BaseClass::ItemPostFrame();
+}
+
+void CWeaponMG42::ItemBusyFrame( void )
+{
+	ItemFrameCool();
+
+	BaseClass::ItemBusyFrame();
+}
+
+void CWeaponMG42::ItemFrameCool( void )
+{
+	if( gpGlobals->curtime > m_flNextCoolTime )
+	{
+		if ( m_iWeaponHeat > 0 )
+			m_iWeaponHeat--;
+
+		m_flNextCoolTime = gpGlobals->curtime + 0.16f;
+	}
+}
+
+bool CWeaponMG42::Deploy( void )
+{
+	// stop the fake cooling when we deploy the weapon
+	SetContextThink( NULL, 0.0, COOL_CONTEXT );
+
+	return BaseClass::Deploy();
+}
+
+bool CWeaponMG42::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+#ifndef CLIENT_DLL
+	SetContextThink( &CWeaponMG42::CoolThink, gpGlobals->curtime + 0.1, COOL_CONTEXT );
+#endif
+
+	return BaseClass::Holster(pSwitchingTo);
+}
+
+void CWeaponMG42::Drop( const Vector &vecVelocity )
+{
+#ifndef CLIENT_DLL
+	SetContextThink( &CWeaponMG42::CoolThink, gpGlobals->curtime + 0.1, COOL_CONTEXT );
+#endif
+
+	BaseClass::Drop( vecVelocity );
+}
+
+Activity CWeaponMG42::GetReloadActivity( void )
+{
+	return ACT_VM_RELOAD;
+}
+
+Activity CWeaponMG42::GetDrawActivity( void )
+{
+	Activity actDraw;
+
+	if( 0 && m_iClip1 <= 0 )
+		actDraw = ACT_VM_DRAW_EMPTY;	
+	else
+		actDraw = ACT_VM_DRAW;
+
+	return actDraw;
+}
+
+Activity CWeaponMG42::GetDeployActivity( void )
+{
+	Activity actDeploy;
+
+	switch ( m_iClip1 )
+	{
+	case 8:
+		actDeploy = ACT_VM_DEPLOY_8;
+		break;
+	case 7:
+		actDeploy = ACT_VM_DEPLOY_7;
+		break;
+	case 6:
+		actDeploy = ACT_VM_DEPLOY_6;
+		break;
+	case 5:
+		actDeploy = ACT_VM_DEPLOY_5;
+		break;
+	case 4:
+		actDeploy = ACT_VM_DEPLOY_4;
+		break;
+	case 3:
+		actDeploy = ACT_VM_DEPLOY_3;
+		break;
+	case 2:
+		actDeploy = ACT_VM_DEPLOY_2;
+		break;
+	case 1:
+		actDeploy = ACT_VM_DEPLOY_1;
+		break;
+	case 0:
+		actDeploy = ACT_VM_DEPLOY_EMPTY;
+		break;
+	default:
+		actDeploy = ACT_VM_DEPLOY;
+		break;
+	}
+
+	return actDeploy;
+}
+
+Activity CWeaponMG42::GetUndeployActivity( void )
+{
+	Activity actUndeploy;
+
+	switch ( m_iClip1 )
+	{
+	case 8:
+		actUndeploy = ACT_VM_UNDEPLOY_8;
+		break;
+	case 7:
+		actUndeploy = ACT_VM_UNDEPLOY_7;
+		break;
+	case 6:
+		actUndeploy = ACT_VM_UNDEPLOY_6;
+		break;
+	case 5:
+		actUndeploy = ACT_VM_UNDEPLOY_5;
+		break;
+	case 4:
+		actUndeploy = ACT_VM_UNDEPLOY_4;
+		break;
+	case 3:
+		actUndeploy = ACT_VM_UNDEPLOY_3;
+		break;
+	case 2:
+		actUndeploy = ACT_VM_UNDEPLOY_2;
+		break;
+	case 1:
+		actUndeploy = ACT_VM_UNDEPLOY_1;
+		break;
+	case 0:
+		actUndeploy = ACT_VM_UNDEPLOY_EMPTY;
+		break;
+	default:
+		actUndeploy = ACT_VM_UNDEPLOY;
+		break;
+	}
+
+	return actUndeploy;
+}
+
+Activity CWeaponMG42::GetIdleActivity( void )
+{
+	Activity actIdle;
+
+	if( IsDeployed() )
+	{
+		switch ( m_iClip1 )
+		{
+		case 8:
+			actIdle = ACT_VM_IDLE_DEPLOYED_8;
+			break;
+		case 7:
+			actIdle = ACT_VM_IDLE_DEPLOYED_7;
+			break;
+		case 6:
+			actIdle = ACT_VM_IDLE_DEPLOYED_6;
+			break;
+		case 5:
+			actIdle = ACT_VM_IDLE_DEPLOYED_5;
+			break;
+		case 4:
+			actIdle = ACT_VM_IDLE_DEPLOYED_4;
+			break;
+		case 3:
+			actIdle = ACT_VM_IDLE_DEPLOYED_3;
+			break;
+		case 2:
+			actIdle = ACT_VM_IDLE_DEPLOYED_2;
+			break;
+		case 1:
+			actIdle = ACT_VM_IDLE_DEPLOYED_1;
+			break;
+		case 0:
+			actIdle = ACT_VM_IDLE_DEPLOYED_EMPTY;
+			break;
+		default:
+			actIdle = ACT_VM_IDLE_DEPLOYED;
+			break;
+		}
+	}
+	else
+	{
+		switch ( m_iClip1 )
+		{
+		case 8:
+			actIdle = ACT_VM_IDLE_8;
+			break;
+		case 7:
+			actIdle = ACT_VM_IDLE_7;
+			break;
+		case 6:
+			actIdle = ACT_VM_IDLE_6;
+			break;
+		case 5:
+			actIdle = ACT_VM_IDLE_5;
+			break;
+		case 4:
+			actIdle = ACT_VM_IDLE_4;
+			break;
+		case 3:
+			actIdle = ACT_VM_IDLE_3;
+			break;
+		case 2:
+			actIdle = ACT_VM_IDLE_2;
+			break;
+		case 1:
+			actIdle = ACT_VM_IDLE_1;
+			break;
+		case 0:
+			actIdle = ACT_VM_IDLE_EMPTY;
+			break;
+		default:
+			actIdle = ACT_VM_IDLE;
+			break;
+		}
+	}
+
+	return actIdle;
+}
+
+Activity CWeaponMG42::GetPrimaryAttackActivity( void )
+{
+	Activity actPrim;
+
+	if( IsDeployed() )
+	{
+		switch ( m_iClip1 )
+		{
+		case 8:
+			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_8;
+			break;
+		case 7:
+			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_7;
+			break;
+		case 6:
+			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_6;
+			break;
+		case 5:
+			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_5;
+			break;
+		case 4:
+			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_4;
+			break;
+		case 3:
+			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_3;
+			break;
+		case 2:
+			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_2;
+			break;
+		case 1:
+			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_1;
+			break;
+		case 0:
+			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_EMPTY;
+			break;
+		default:
+			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED;
+			break;
+		}
+	}
+	else
+	{
+		switch ( m_iClip1 )
+		{
+		case 8:
+			actPrim = ACT_VM_PRIMARYATTACK_8;
+			break;
+		case 7:
+			actPrim = ACT_VM_PRIMARYATTACK_7;
+			break;
+		case 6:
+			actPrim = ACT_VM_PRIMARYATTACK_6;
+			break;
+		case 5:
+			actPrim = ACT_VM_PRIMARYATTACK_5;
+			break;
+		case 4:
+			actPrim = ACT_VM_PRIMARYATTACK_4;
+			break;
+		case 3:
+			actPrim = ACT_VM_PRIMARYATTACK_3;
+			break;
+		case 2:
+			actPrim = ACT_VM_PRIMARYATTACK_2;
+			break;
+		case 1:
+			actPrim = ACT_VM_PRIMARYATTACK_1;
+			break;
+		case 0:
+			actPrim = ACT_VM_PRIMARYATTACK_EMPTY;
+			break;
+		default:
+			actPrim = ACT_VM_PRIMARYATTACK;
+			break;
+		}
+	}
+
+	return actPrim;
+}
+
+float CWeaponMG42::GetRecoil( void )
+{
+	CDODPlayer *p = ToDODPlayer( GetPlayerOwner() );
+
+	if( p && p->m_Shared.IsInMGDeploy() )
+	{
+		return 0.0f;
+	}
+
+	return 20;
+}
+
+#ifdef CLIENT_DLL
+
+//-----------------------------------------------------------------------------
+// This is called after sending this entity's recording state
+//-----------------------------------------------------------------------------
+void CWeaponMG42::CleanupToolRecordingState( KeyValues *msg )
+{
+	BaseClass::CleanupToolRecordingState( msg );
+
+	// Generally, this is used to allow the entity to clean up
+	// allocated state it put into the message, but here we're going
+	// to use it to send particle system messages because we
+	// know the smoke has been recorded at this point
+	if ( !clienttools->IsInRecordingMode() || !m_pEmitter.IsValid() )
+		return;
+
+	// NOTE: Particle system destruction message will be sent by the particle effect itself.
+	if ( m_pEmitter->GetToolParticleEffectId() == TOOLPARTICLESYSTEMID_INVALID )
+	{
+		int nId = m_pEmitter->AllocateToolParticleEffectId();
+
+		KeyValues *msg = new KeyValues( "ParticleSystem_Create" );
+		msg->SetString( "name", "CWeaponMG42 smoke" );
+		msg->SetInt( "id", nId );
+		msg->SetFloat( "time", gpGlobals->curtime );
+
+		KeyValues *pEmitter0 = msg->FindKey( "DmeSpriteEmitter", true );
+		pEmitter0->SetInt( "count", 5 );	// particles per second, when duration is < 0
+		pEmitter0->SetFloat( "duration", -1 );
+		pEmitter0->SetString( "material", "sprites/effects/bazookapuff" );
+		pEmitter0->SetInt( "active", 0 );
+
+		KeyValues *pInitializers = pEmitter0->FindKey( "initializers", true );
+
+		KeyValues *pPosition = pInitializers->FindKey( "DmeRandomAttachmentPositionEntityInitializer", true );
+		pPosition->SetPtr( "entindex", (void*)entindex() );
+ 		pPosition->SetInt( "attachmentIndex0", 1 );
+ 		pPosition->SetInt( "attachmentIndex1", 2 );
+
+		KeyValues *pLifetime = pInitializers->FindKey( "DmeRandomLifetimeInitializer", true );
+		pLifetime->SetFloat( "minLifetime", 1.8f );
+ 		pLifetime->SetFloat( "maxLifetime", 1.8f );
+
+		KeyValues *pVelocity = pInitializers->FindKey( "DmeConstantVelocityInitializer", true );
+		pVelocity->SetFloat( "velocityX", 0.0f );
+		pVelocity->SetFloat( "velocityY", 0.0f );
+		pVelocity->SetFloat( "velocityZ", 12.0f );
+
+		KeyValues *pRoll = pInitializers->FindKey( "DmeRandomRollInitializer", true );
+		pRoll->SetFloat( "minRoll", 0.0f );
+ 		pRoll->SetFloat( "maxRoll", 0.5f );
+
+		KeyValues *pRollSpeed = pInitializers->FindKey( "DmeSplitRandomRollSpeedInitializer", true );
+		pRollSpeed->SetFloat( "minRollSpeed", 0.5f );
+ 		pRollSpeed->SetFloat( "maxRollSpeed", 1.0f );
+
+		KeyValues *pColor = pInitializers->FindKey( "DmeRandomInterpolatedColorInitializer", true );
+ 		pColor->SetColor( "color1", Color( 200, 200, 200, 255 ) );
+ 		pColor->SetColor( "color2", Color( 200, 200, 200, 255 ) );
+
+		KeyValues *pAlpha = pInitializers->FindKey( "DmeRandomAlphaInitializer", true );
+		pAlpha->SetInt( "minStartAlpha", 60 );
+		pAlpha->SetInt( "maxStartAlpha", 60 );
+		pAlpha->SetInt( "minEndAlpha", 0 );
+		pAlpha->SetInt( "maxEndAlpha", 0 );
+
+		KeyValues *pSize = pInitializers->FindKey( "DmeRandomSizeInitializer", true );
+		pSize->SetFloat( "minStartSize", 4 );
+		pSize->SetFloat( "maxStartSize", 4 );
+		pSize->SetFloat( "minEndSize", 25 );
+		pSize->SetFloat( "maxEndSize", 25 );
+
+		KeyValues *pUpdaters = pEmitter0->FindKey( "updaters", true );
+
+		pUpdaters->FindKey( "DmePositionVelocityUpdater", true );
+		pUpdaters->FindKey( "DmeRollUpdater", true );
+		pUpdaters->FindKey( "DmeAlphaLinearUpdater", true );
+		pUpdaters->FindKey( "DmeSizeUpdater", true );
+
+		// create emitters for each emission rate: 5,10,20,30
+		KeyValues *pEmitter1 = pEmitter0->MakeCopy();
+		pEmitter1->SetInt( "count", 10 );
+		msg->AddSubKey( pEmitter1 );
+
+		KeyValues *pEmitter2 = pEmitter0->MakeCopy();
+		pEmitter2->SetInt( "count", 20 );
+		msg->AddSubKey( pEmitter2 );
+
+		KeyValues *pEmitter3 = pEmitter0->MakeCopy();
+		pEmitter3->SetInt( "count", 30 );
+		msg->AddSubKey( pEmitter3 );
+
+		// mark only the appropriate emitter active
+		bool bHolstered = GetOwner() && GetOwner()->GetActiveWeapon() != this;
+		if ( !bHolstered )
+		{
+			if ( m_iWeaponHeat > 85 )
+			{
+				pEmitter3->SetInt( "active", 1 );
+			}
+			else if ( m_iWeaponHeat > 80 )
+			{
+				pEmitter2->SetInt( "active", 1 );
+			}
+			else if ( m_iWeaponHeat > 65 )
+			{
+				pEmitter1->SetInt( "active", 1 );
+			}
+			else if ( m_iWeaponHeat > 50 )
+			{
+				pEmitter0->SetInt( "active", 1 );
+			}
+		}
+
+		ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );
+		msg->deleteThis();
+	}
+	else
+	{
+		int nEmitterIndex = -1;
+		bool bHolstered = GetOwner() && GetOwner()->GetActiveWeapon() != this;
+		if ( !bHolstered )
+		{
+			if ( m_iWeaponHeat > 85 )
+			{
+				nEmitterIndex = 3;
+			}
+			else if ( m_iWeaponHeat > 80 )
+			{
+				nEmitterIndex = 2;
+			}
+			else if ( m_iWeaponHeat > 65 )
+			{
+				nEmitterIndex = 1;
+			}
+			else if ( m_iWeaponHeat > 50 )
+			{
+				nEmitterIndex = 0;
+			}
+		}
+
+		KeyValues *msg = new KeyValues( "ParticleSystem_ActivateEmitter" );
+		msg->SetInt( "id", m_pEmitter->GetToolParticleEffectId() );
+		msg->SetFloat( "time", gpGlobals->curtime );
+
+		msg->SetInt( "emitter", 0 );
+		msg->SetInt( "active", nEmitterIndex == 0 );
+		ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );
+
+		msg->SetInt( "emitter", 1 );
+		msg->SetInt( "active", nEmitterIndex == 1 );
+		ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );
+
+		msg->SetInt( "emitter", 2 );
+		msg->SetInt( "active", nEmitterIndex == 2 );
+		ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );
+
+		msg->SetInt( "emitter", 3 );
+		msg->SetInt( "active", nEmitterIndex == 3 );
+		ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );
+
+		msg->deleteThis();
+	}
+}
+
+#endif

game/shared/dod/weapon_mg42.h

@@ -0,0 +1,108 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+//=============================================================================//
+
+#ifndef WEAPON_MG42_H
+#define WEAPON_MG42_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "weapon_dodbase.h"
+#include "weapon_dodbipodgun.h"
+
+#if defined( CLIENT_DLL )
+	#define CWeaponMG42 C_WeaponMG42
+#endif
+
+
+#define COOL_CONTEXT "CoolContext"
+
+class CWeaponMG42 : public CDODBipodWeapon
+{
+public:
+	DECLARE_CLASS( CWeaponMG42, CDODBipodWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+
+#ifdef GAME_DLL
+	DECLARE_DATADESC();
+#endif
+	
+	CWeaponMG42()  {}
+#ifdef CLIENT_DLL
+	virtual ~CWeaponMG42();
+#endif
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_MG42; }
+
+	// weapon id for stats purposes
+	virtual DODWeaponID GetStatsWeaponID( void )
+	{
+		if ( !IsDeployed() )
+			return WEAPON_MG42_UNDEPLOYED;
+		else 
+			return WEAPON_MG42;
+	}
+
+	virtual void Spawn();
+	virtual void Precache();
+	virtual void PrimaryAttack( void );
+	virtual bool Reload( void );
+	virtual void FinishReload( void );
+	virtual void ItemPostFrame( void );
+	virtual void ItemBusyFrame( void );
+	void ItemFrameCool( void );
+	virtual bool Deploy( void );
+	virtual bool Holster( CBaseCombatWeapon *pSwitchingTo );
+	virtual void Drop( const Vector &vecVelocity );
+
+	virtual Activity GetReloadActivity( void );
+	virtual Activity GetDrawActivity( void );
+	virtual Activity GetDeployActivity( void );
+	virtual Activity GetUndeployActivity( void );
+	virtual Activity GetIdleActivity( void );
+	virtual Activity GetPrimaryAttackActivity( void );
+
+	int GetWeaponHeat( void ) { return m_iWeaponHeat; }
+	
+	virtual bool ShouldDrawCrosshair( void ) { return IsDeployed(); }
+
+	void Cool( void );
+
+#ifdef CLIENT_DLL
+	virtual void ClientThink( void );
+	virtual void OnDataChanged( DataUpdateType_t updateType );
+	virtual void CleanupToolRecordingState( KeyValues *msg );
+
+	void EmitSmokeParticle( void );
+#else
+	void CoolThink( void );
+#endif 
+
+	virtual float GetRecoil( void );
+
+private:
+	CWeaponMG42( const CWeaponMG42 & );
+
+	CNetworkVar( int, m_iWeaponHeat );
+	CNetworkVar( float,	m_flNextCoolTime );
+
+	CNetworkVar( bool,	m_bOverheated );
+
+#ifdef CLIENT_DLL
+
+	CSmartPtr<CSimpleEmitter> m_pEmitter;
+
+	float			m_flParticleAccumulator;
+	PMaterialHandle m_hParticleMaterial;
+
+#endif
+
+};
+
+#endif //WEAPON_MG42_H

game/shared/dod/weapon_mp40.cpp

@@ -0,0 +1,94 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodfullauto_punch.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponMP40 C_WeaponMP40
+
+#endif
+
+
+class CWeaponMP40 : public CDODFullAutoPunchWeapon
+{
+public:
+	DECLARE_CLASS( CWeaponMP40, CDODFullAutoPunchWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+	
+	CWeaponMP40()  {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_MP40; }
+	virtual DODWeaponID GetAltWeaponID( void ) const	{ return WEAPON_MP40_PUNCH; }
+
+	virtual Activity GetIdleActivity( void );
+
+	virtual float GetRecoil( void ) { return 2.2f; }
+
+private:
+	CWeaponMP40( const CWeaponMP40 & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponMP40, DT_WeaponMP40 )
+
+BEGIN_NETWORK_TABLE( CWeaponMP40, DT_WeaponMP40 )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponMP40 )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_mp40, CWeaponMP40 );
+PRECACHE_WEAPON_REGISTER( weapon_mp40 );
+
+acttable_t CWeaponMP40::m_acttable[] = 
+{
+	{ ACT_DOD_STAND_AIM,					ACT_DOD_STAND_AIM_MP40,					false },
+	{ ACT_DOD_CROUCH_AIM,					ACT_DOD_CROUCH_AIM_MP40,				false },
+	{ ACT_DOD_CROUCHWALK_AIM,				ACT_DOD_CROUCHWALK_AIM_MP40,			false },
+	{ ACT_DOD_WALK_AIM,						ACT_DOD_WALK_AIM_MP40,					false },
+	{ ACT_DOD_RUN_AIM,						ACT_DOD_RUN_AIM_MP40,					false },
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_MP40,					false },
+	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_IDLE_MP40,			false },
+	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_IDLE_MP40,				false },
+	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_IDLE_MP40,				false },
+	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_IDLE_MP40,			false },
+	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_IDLE_MP40,					false },
+	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_IDLE_MP40,					false },
+	{ ACT_SPRINT,							ACT_DOD_SPRINT_IDLE_MP40,				false },
+
+	{ ACT_RANGE_ATTACK1,					ACT_DOD_PRIMARYATTACK_MP40,			false },
+	{ ACT_DOD_PRIMARYATTACK_CROUCH,			ACT_DOD_PRIMARYATTACK_MP40,			false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE,			ACT_DOD_PRIMARYATTACK_PRONE_MP40,	false },
+	{ ACT_RANGE_ATTACK2,					ACT_DOD_SECONDARYATTACK_MP40,		false },
+	{ ACT_DOD_SECONDARYATTACK_CROUCH,		ACT_DOD_SECONDARYATTACK_CROUCH_MP40,false },
+	{ ACT_DOD_SECONDARYATTACK_PRONE,		ACT_DOD_SECONDARYATTACK_PRONE_MP40,	false },
+
+	{ ACT_RELOAD,							ACT_DOD_RELOAD_MP40,				false },
+	{ ACT_DOD_RELOAD_CROUCH,				ACT_DOD_RELOAD_CROUCH_MP40,			false },
+	{ ACT_DOD_RELOAD_PRONE,					ACT_DOD_RELOAD_PRONE_MP40,			false },
+
+	// Hand Signals
+	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_MP44,				false },
+	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_MP44,				false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponMP40 );
+
+Activity CWeaponMP40::GetIdleActivity( void )
+{
+	Activity actIdle;
+
+	if( m_iClip1 < GetMaxClip1() )
+		actIdle = ACT_VM_IDLE_EMPTY;	
+	else
+		actIdle = ACT_VM_IDLE;
+
+	return actIdle;
+}

game/shared/dod/weapon_mp44.cpp

@@ -0,0 +1,87 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodfireselect.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponMP44 C_WeaponMP44
+
+#endif
+
+
+class CWeaponMP44 : public CDODFireSelectWeapon
+{
+public:
+	DECLARE_CLASS( CWeaponMP44, CDODFireSelectWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+	
+	CWeaponMP44()  {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_MP44; }
+
+	// weapon id for stats purposes
+	virtual DODWeaponID GetStatsWeaponID( void )
+	{
+		if ( IsSemiAuto() )
+			return WEAPON_MP44_SEMIAUTO;
+		else 
+			return WEAPON_MP44;
+	}
+
+	virtual float GetRecoil( void ) { return 5.0f; }
+
+private:
+	CWeaponMP44( const CWeaponMP44 & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponMP44, DT_WeaponMP44 )
+
+BEGIN_NETWORK_TABLE( CWeaponMP44, DT_WeaponMP44 )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponMP44 )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_mp44, CWeaponMP44 );
+PRECACHE_WEAPON_REGISTER( weapon_mp44 );
+
+acttable_t CWeaponMP44::m_acttable[] = 
+{
+	{ ACT_DOD_STAND_AIM,					ACT_DOD_STAND_AIM_MP44,					false },
+	{ ACT_DOD_CROUCH_AIM,					ACT_DOD_CROUCH_AIM_MP44,				false },
+	{ ACT_DOD_CROUCHWALK_AIM,				ACT_DOD_CROUCHWALK_AIM_MP44,			false },
+	{ ACT_DOD_WALK_AIM,						ACT_DOD_WALK_AIM_MP44,					false },
+	{ ACT_DOD_RUN_AIM,						ACT_DOD_RUN_AIM_MP44,					false },
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_MP44,					false },
+	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_IDLE_MP44,			false },
+	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_IDLE_MP44,				false },
+	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_IDLE_MP44,				false },
+	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_IDLE_MP44,			false },
+	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_IDLE_MP44,					false },
+	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_IDLE_MP44,					false },
+	{ ACT_SPRINT,							ACT_DOD_SPRINT_IDLE_MP44,				false },
+
+	// Attack ( prone? )
+	{ ACT_RANGE_ATTACK1,					ACT_DOD_PRIMARYATTACK_MP44,			false },
+	{ ACT_DOD_PRIMARYATTACK_CROUCH,			ACT_DOD_PRIMARYATTACK_MP44,			false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE,			ACT_DOD_PRIMARYATTACK_PRONE_MP44,	false },
+
+	// Reload ( prone? )
+	{ ACT_RELOAD,							ACT_DOD_RELOAD_MP44,				false },
+	{ ACT_DOD_RELOAD_CROUCH,				ACT_DOD_RELOAD_CROUCH_MP44,			false },
+	{ ACT_DOD_RELOAD_PRONE,					ACT_DOD_RELOAD_PRONE_MP44,			false },
+
+	// Hand Signals
+	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_MP44,				false },
+	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_MP44,				false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponMP44 );

game/shared/dod/weapon_p38.cpp

@@ -0,0 +1,115 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodsemiauto.h"
+
+#if defined( CLIENT_DLL )
+
+#define CWeaponP38 C_WeaponP38
+
+#endif
+
+
+class CWeaponP38 : public CDODSemiAutoWeapon
+{
+public:
+	DECLARE_CLASS( CWeaponP38, CDODSemiAutoWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+
+	CWeaponP38()  {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_P38; }
+
+	virtual Activity GetIdleActivity( void );
+	virtual Activity GetPrimaryAttackActivity( void );
+	virtual Activity GetDrawActivity( void );
+
+	virtual float GetRecoil( void ) { return 1.4f; }
+
+private:
+	CWeaponP38( const CWeaponP38 & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponP38, DT_WeaponP38 )
+
+BEGIN_NETWORK_TABLE( CWeaponP38, DT_WeaponP38 )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponP38 )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_p38, CWeaponP38 );
+PRECACHE_WEAPON_REGISTER( weapon_p38 );
+
+acttable_t CWeaponP38::m_acttable[] = 
+{
+	{ ACT_DOD_STAND_AIM,					ACT_DOD_STAND_AIM_PISTOL,				false },
+	{ ACT_DOD_CROUCH_AIM,					ACT_DOD_CROUCH_AIM_PISTOL,				false },
+	{ ACT_DOD_CROUCHWALK_AIM,				ACT_DOD_CROUCHWALK_AIM_PISTOL,			false },
+	{ ACT_DOD_WALK_AIM,						ACT_DOD_WALK_AIM_PISTOL,				false },
+	{ ACT_DOD_RUN_AIM,						ACT_DOD_RUN_AIM_PISTOL,					false },
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_PISTOL,				false },
+	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_IDLE_PISTOL,			false },
+	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_IDLE_PISTOL,				false },
+	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_IDLE_PISTOL,				false },
+	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_IDLE_PISTOL,			false },
+	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_IDLE_PISTOL,				false },
+	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_IDLE_PISTOL,				false },
+	{ ACT_SPRINT,							ACT_DOD_SPRINT_IDLE_PISTOL,				false },
+
+	{ ACT_RANGE_ATTACK1,					ACT_DOD_PRIMARYATTACK_PISTOL,			false },
+	{ ACT_DOD_PRIMARYATTACK_CROUCH,			ACT_DOD_PRIMARYATTACK_PISTOL,			false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE,			ACT_DOD_PRIMARYATTACK_PRONE_PISTOL,		false },
+
+	{ ACT_RELOAD,							ACT_DOD_RELOAD_PISTOL,					false },
+	{ ACT_DOD_RELOAD_CROUCH,				ACT_DOD_RELOAD_CROUCH_PISTOL,			false },
+	{ ACT_DOD_RELOAD_PRONE,					ACT_DOD_RELOAD_PRONE_PISTOL,			false },
+
+	// Hand Signals
+	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_PISTOL,					false },
+	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_PISTOL,				false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponP38 );
+
+Activity CWeaponP38::GetIdleActivity( void )
+{
+	Activity actIdle;
+
+	if( m_iClip1 <= 0 )
+		actIdle = ACT_VM_IDLE_EMPTY;	
+	else
+		actIdle = ACT_VM_IDLE;
+
+	return actIdle;
+}
+
+Activity CWeaponP38::GetPrimaryAttackActivity( void )
+{
+	Activity actPrim;
+
+	if( m_iClip1 <= 0 )
+		actPrim = ACT_VM_PRIMARYATTACK_EMPTY;	
+	else
+		actPrim = ACT_VM_PRIMARYATTACK;
+
+	return actPrim;
+}
+
+Activity CWeaponP38::GetDrawActivity( void )
+{
+	Activity actDraw;
+
+	if( m_iClip1 <= 0 )
+		actDraw = ACT_VM_DRAW_EMPTY;	
+	else
+		actDraw = ACT_VM_DRAW;
+
+	return actDraw;
+}

game/shared/dod/weapon_pschreck.cpp

@@ -0,0 +1,102 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodbaserpg.h"
+
+#ifndef CLIENT_DLL
+	#include "rocket_pschreck.h"
+#endif
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponPschreck C_WeaponPschreck
+
+#endif
+
+
+class CWeaponPschreck : public CDODBaseRocketWeapon
+{
+public:
+	DECLARE_CLASS( CWeaponPschreck, CDODBaseRocketWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+	
+	CWeaponPschreck()  {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_PSCHRECK; }
+
+	virtual void FireRocket( void );
+
+private:
+	CWeaponPschreck( const CWeaponPschreck & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponPschreck, DT_WeaponPschreck )
+
+BEGIN_NETWORK_TABLE( CWeaponPschreck, DT_WeaponPschreck )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponPschreck )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_pschreck, CWeaponPschreck );
+PRECACHE_WEAPON_REGISTER( weapon_pschreck );
+
+acttable_t CWeaponPschreck::m_acttable[] = 
+{
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_PSCHRECK,				false },
+	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_IDLE_PSCHRECK,		false },
+	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_IDLE_PSCHRECK,			false },
+	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_IDLE_PSCHRECK,			false },
+	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_IDLE_PSCHRECK,		false },
+	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_IDLE_PSCHRECK,				false },
+	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_IDLE_PSCHRECK,				false },
+	{ ACT_SPRINT,							ACT_DOD_SPRINT_IDLE_PSCHRECK,			false },
+
+	// Zoomed Aim
+	{ ACT_DOD_IDLE_ZOOMED,					ACT_DOD_STAND_ZOOM_PSCHRECK,			false },
+	{ ACT_DOD_CROUCH_ZOOMED,				ACT_DOD_CROUCH_ZOOM_PSCHRECK,			false },
+	{ ACT_DOD_CROUCHWALK_ZOOMED,			ACT_DOD_CROUCHWALK_ZOOM_PSCHRECK,		false },
+	{ ACT_DOD_WALK_ZOOMED,					ACT_DOD_WALK_ZOOM_PSCHRECK,				false },
+	{ ACT_DOD_PRONE_ZOOMED,					ACT_DOD_PRONE_ZOOM_PSCHRECK,			false },
+	{ ACT_DOD_PRONE_FORWARD_ZOOMED,			ACT_DOD_PRONE_ZOOM_FORWARD_PSCHRECK,	false },
+
+	// Attack ( must be zoomed )
+	{ ACT_RANGE_ATTACK1,					ACT_DOD_PRIMARYATTACK_PSCHRECK,			false },
+	{ ACT_DOD_PRIMARYATTACK_CROUCH,			ACT_DOD_PRIMARYATTACK_PSCHRECK,			false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE,			ACT_DOD_PRIMARYATTACK_PRONE_PSCHRECK,	false },
+
+	// Reload ( zoomed or not, prone or not )
+	{ ACT_RELOAD,							ACT_DOD_RELOAD_PSCHRECK,				false },
+	{ ACT_DOD_RELOAD_CROUCH,				ACT_DOD_RELOAD_CROUCH_PSCHRECK,			false },
+	{ ACT_DOD_RELOAD_PRONE,					ACT_DOD_RELOAD_PRONE_PSCHRECK,			false },	
+	{ ACT_DOD_RELOAD_DEPLOYED,				ACT_DOD_ZOOMLOAD_PSCHRECK,				false },
+	{ ACT_DOD_RELOAD_PRONE_DEPLOYED,		ACT_DOD_ZOOMLOAD_PRONE_PSCHRECK,		false },
+
+	// Hand Signals
+	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_PSCHRECK,				false },
+	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_PSCHRECK,				false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponPschreck );
+
+void CWeaponPschreck::FireRocket( void )
+{
+#ifndef CLIENT_DLL
+
+	CBasePlayer *pPlayer = GetPlayerOwner();
+
+#ifdef DBGFLAG_ASSERT
+	CPschreckRocket *pRocket = 
+#endif //DEBUG		
+		CPschreckRocket::Create( pPlayer->Weapon_ShootPosition(), pPlayer->GetAbsAngles(), pPlayer );
+
+	Assert( pRocket );
+
+#endif
+}

game/shared/dod/weapon_riflegrenade.cpp

@@ -0,0 +1,233 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h" 
+#include "fx_dod_shared.h"
+#include "weapon_riflegrenade.h"
+
+#ifdef CLIENT_DLL
+	#include "prediction.h"
+#endif
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponBaseRifleGrenade, DT_WeaponBaseRifleGrenade )
+
+BEGIN_NETWORK_TABLE( CWeaponBaseRifleGrenade, DT_WeaponBaseRifleGrenade )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponBaseRifleGrenade )
+END_PREDICTION_DATA()
+
+
+CWeaponBaseRifleGrenade::CWeaponBaseRifleGrenade()
+{
+}
+
+void CWeaponBaseRifleGrenade::Spawn()
+{
+	BaseClass::Spawn();
+}
+
+void CWeaponBaseRifleGrenade::PrimaryAttack( void )
+{
+	CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+
+	Assert( pPlayer );
+
+	// Out of ammo?
+	if ( m_iClip1 <= 0 )
+	{
+		if (m_bFireOnEmpty)
+		{
+			PlayEmptySound();
+			m_flNextPrimaryAttack = gpGlobals->curtime + 0.2;
+		}
+		return;
+	}
+
+	if( pPlayer->GetWaterLevel() > 2 )
+	{
+		PlayEmptySound();
+		m_flNextPrimaryAttack = gpGlobals->curtime + 1.0;
+		return;
+	}
+
+	// decrement before calling PlayPrimaryAttackAnim, so we can play the empty anim if necessary
+	m_iClip1--;
+
+	SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+
+	// player "shoot" animation
+	pPlayer->SetAnimation( PLAYER_ATTACK1 );
+
+#ifdef CLIENT_DLL
+	if( pPlayer && !pPlayer->IsDormant() )
+		pPlayer->DoAnimationEvent( PLAYERANIMEVENT_FIRE_GUN );
+#else
+	if( pPlayer )
+		pPlayer->DoAnimationEvent( PLAYERANIMEVENT_FIRE_GUN );
+#endif	
+
+#ifndef CLIENT_DLL
+	ShootGrenade();
+#endif
+
+	WeaponSound( SINGLE );
+
+	DoFireEffects();
+
+#ifdef CLIENT_DLL
+	CDODPlayer *p = ToDODPlayer( GetPlayerOwner() );
+
+	if ( prediction->IsFirstTimePredicted() )
+		p->DoRecoil( GetWeaponID(), GetRecoil() );
+#endif
+
+	m_flNextPrimaryAttack = m_flNextSecondaryAttack = gpGlobals->curtime + GetFireDelay();
+	m_flTimeWeaponIdle = gpGlobals->curtime + m_pWeaponInfo->m_flTimeToIdleAfterFire;
+
+#ifndef CLIENT_DLL
+	IGameEvent * event = gameeventmanager->CreateEvent( "dod_stats_weapon_attack" );
+	if ( event )
+	{
+		event->SetInt( "attacker", pPlayer->GetUserID() );
+		event->SetInt( "weapon", GetStatsWeaponID() );
+
+		gameeventmanager->FireEvent( event );
+	}
+#endif	//CLIENT_DLL
+}
+
+Activity CWeaponBaseRifleGrenade::GetDrawActivity( void )
+{
+	return ( (m_iClip1 <= 0 ) ? ACT_VM_DRAW_EMPTY : ACT_VM_DRAW );
+}
+
+Activity CWeaponBaseRifleGrenade::GetIdleActivity( void )
+{
+	return ( (m_iClip1 <= 0 ) ? ACT_VM_IDLE_EMPTY : ACT_VM_IDLE );
+}
+
+bool CWeaponBaseRifleGrenade::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+#ifndef CLIENT_DLL
+	// If they attempt to switch weapons before the throw animation is done, 
+	// allow it, but kill the weapon if we have to.
+	CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+
+	if( pPlayer && pPlayer->GetAmmoCount(m_iPrimaryAmmoType) <= 0 && m_iClip1 <= 0 )
+	{
+		pPlayer->Weapon_Drop( this, NULL, NULL );
+		UTIL_Remove(this);
+		return true;	
+	}
+#endif
+
+	return BaseClass::Holster( pSwitchingTo );
+}
+
+// weapon idle to destroy weapon if empty
+void CWeaponBaseRifleGrenade::WeaponIdle( void )
+{
+#ifndef CLIENT_DLL
+	CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
+	if (pPlayer->GetAmmoCount(m_iPrimaryAmmoType) <= 0 && m_iClip1 <= 0)
+	{
+		pPlayer->Weapon_Drop( this, NULL, NULL );
+		UTIL_Remove(this);
+		return;
+	}
+#endif
+
+	BaseClass::WeaponIdle();
+}
+
+#define DOD_RIFLEGRENADE_SPEED	2000
+extern ConVar dod_grenadegravity;
+
+#ifndef CLIENT_DLL
+
+	void CWeaponBaseRifleGrenade::ShootGrenade( void )
+	{
+		CDODPlayer *pPlayer = ToDODPlayer( GetOwner() );
+		if ( !pPlayer )
+		{
+			Assert( false );
+			return;
+		}
+
+		QAngle angThrow = pPlayer->LocalEyeAngles();
+
+		Vector vForward, vRight, vUp;
+		AngleVectors( angThrow, &vForward, &vRight, &vUp );
+
+		Vector eyes = pPlayer->GetAbsOrigin() + pPlayer->GetViewOffset();
+		Vector vecSrc = eyes; 	
+		Vector vecThrow = vForward * DOD_RIFLEGRENADE_SPEED;
+
+		// raise origin enough so that you can't shoot it straight down through the world
+		if ( pPlayer->m_Shared.IsProne() )
+		{
+			vecSrc.z += 16;
+		}
+
+		SetCollisionGroup( COLLISION_GROUP_WEAPON );
+
+		QAngle angles;
+		VectorAngles( -vecThrow, angles );
+
+		// estimate angular velocity based on initial conditions
+		// uses a constant ang velocity instead of the derivative of the flight path, oh well.
+		AngularImpulse angImpulse;
+		angImpulse.Init();
+
+		if ( vecThrow.z > 0 )
+            angImpulse.y = -angles.x / ( sqrt( (-2 * vecThrow.z) / dod_grenadegravity.GetFloat() ));
+		else
+			angImpulse.y = -10;
+		
+		EmitGrenade( vecSrc, angles, vecThrow, angImpulse, pPlayer, RIFLEGRENADE_FUSE_LENGTH );
+	}
+
+	void CWeaponBaseRifleGrenade::EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer, float flLifeTime )
+	{
+		Assert( !"Deriving classes should define this" );
+	}
+
+#endif
+
+bool CWeaponBaseRifleGrenade::CanDeploy( void )
+{
+	// does the player own the weapon that fires this grenade?
+	CBasePlayer *pPlayer = GetPlayerOwner();
+
+	if ( !pPlayer )
+		return false;
+
+	CBaseCombatWeapon *pOwnedWeapon = pPlayer->Weapon_OwnsThisType( GetCompanionWeaponName() );
+
+	if ( pOwnedWeapon == NULL )
+		return false;
+
+	return BaseClass::CanDeploy();
+}
+
+const char *CWeaponBaseRifleGrenade::GetCompanionWeaponName( void )
+{
+	Assert( !"Should not call this version. Inheriting classes must implement." );
+	return "";
+}
+
+float CWeaponBaseRifleGrenade::GetRecoil( void )
+{
+	CDODPlayer *p = ToDODPlayer( GetPlayerOwner() );
+
+	if( p && p->m_Shared.IsInMGDeploy() )
+	{
+		return 0.0f;
+	}
+
+	return 10;
+}

game/shared/dod/weapon_riflegrenade.h

@@ -0,0 +1,48 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"  
+#include "shake.h" 
+#include "weapon_dodbasegun.h"
+
+#if defined( CLIENT_DLL )
+#define CWeaponBaseRifleGrenade C_WeaponBaseRifleGrenade
+#endif
+
+class CWeaponBaseRifleGrenade : public CWeaponDODBaseGun
+{
+public:
+	DECLARE_CLASS( CWeaponBaseRifleGrenade, CWeaponDODBaseGun );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+
+	CWeaponBaseRifleGrenade();
+
+	virtual void Spawn();
+	virtual void PrimaryAttack( void );
+	virtual bool Holster( CBaseCombatWeapon *pSwitchingTo );
+	virtual void WeaponIdle( void );
+
+	virtual DODWeaponID GetWeaponID( void ) const { return WEAPON_NONE; }
+	
+
+	virtual Activity GetDrawActivity( void );
+	virtual Activity GetIdleActivity( void );
+
+	virtual bool CanDeploy( void );
+
+	virtual const char *GetCompanionWeaponName( void );
+
+	virtual float GetRecoil( void );
+
+#ifndef CLIENT_DLL
+	void ShootGrenade( void );
+	virtual void EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer, float flLifeTime );
+#endif
+
+private:
+	CWeaponBaseRifleGrenade( const CWeaponBaseRifleGrenade & );
+};

game/shared/dod/weapon_riflegrenade_ger.cpp

@@ -0,0 +1,91 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_riflegrenade.h"
+
+#if defined( CLIENT_DLL )
+
+#include "c_dod_player.h"
+#define CWeaponRifleGrenadeGER C_WeaponRifleGrenadeGER
+
+#else
+
+#include "dod_riflegrenade_ger.h"
+#include "dod_player.h"
+
+#endif
+
+class CWeaponRifleGrenadeGER : public CWeaponBaseRifleGrenade
+{
+public:
+	DECLARE_CLASS( CWeaponRifleGrenadeGER, CWeaponBaseRifleGrenade );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+
+	CWeaponRifleGrenadeGER()  {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_RIFLEGREN_GER; }
+
+#ifndef CLIENT_DLL
+	virtual void EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer, float flLifeTime = GRENADE_FUSE_LENGTH )
+	{
+		CDODRifleGrenadeGER::Create( vecSrc, vecAngles, vecVel, angImpulse, pPlayer, flLifeTime, GetWeaponID() );
+	}
+#endif
+
+	virtual const char *GetCompanionWeaponName( void )
+	{
+		return "weapon_k98";
+	}
+
+private:
+	CWeaponRifleGrenadeGER( const CWeaponRifleGrenadeGER & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponRifleGrenadeGER, DT_WeaponRifleGrenadeGER )
+
+BEGIN_NETWORK_TABLE( CWeaponRifleGrenadeGER, DT_WeaponRifleGrenadeGER )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponRifleGrenadeGER )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_riflegren_ger, CWeaponRifleGrenadeGER );
+PRECACHE_WEAPON_REGISTER( weapon_riflegren_ger );
+
+acttable_t CWeaponRifleGrenadeGER::m_acttable[] = 
+{
+	{ ACT_DOD_STAND_AIM,					ACT_DOD_STAND_AIM_RIFLE,				false },
+	{ ACT_DOD_CROUCH_AIM,					ACT_DOD_CROUCH_AIM_RIFLE,				false },
+	{ ACT_DOD_CROUCHWALK_AIM,				ACT_DOD_CROUCHWALK_AIM_RIFLE,			false },
+	{ ACT_DOD_WALK_AIM,						ACT_DOD_WALK_AIM_RIFLE,					false },
+	{ ACT_DOD_RUN_AIM,						ACT_DOD_RUN_AIM_RIFLE,					false },
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_RIFLE,				false },
+	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_IDLE_RIFLE,			false },
+	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_IDLE_RIFLE,				false },
+	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_IDLE_RIFLE,				false },
+	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_IDLE_RIFLE,			false },
+	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_IDLE_RIFLE,				false },
+	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_IDLE_RIFLE,					false },
+	{ ACT_SPRINT,							ACT_DOD_SPRINT_IDLE_RIFLE,				false },
+
+	// Attack ( prone? deployed? )
+	{ ACT_RANGE_ATTACK1,					ACT_DOD_PRIMARYATTACK_RIFLE,			false },
+	{ ACT_DOD_PRIMARYATTACK_CROUCH,			ACT_DOD_PRIMARYATTACK_RIFLE,			false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE,			ACT_DOD_PRIMARYATTACK_PRONE_RIFLE,		false },
+
+	{ ACT_RELOAD,							ACT_DOD_RELOAD_RIFLEGRENADE,			false },
+	{ ACT_DOD_RELOAD_CROUCH,				ACT_DOD_RELOAD_CROUCH_RIFLEGRENADE,		false },
+	{ ACT_DOD_RELOAD_PRONE,					ACT_DOD_RELOAD_PRONE_RIFLEGRENADE,		false },
+
+	// Hand Signals
+	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_K98,					false },
+	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_K98,					false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponRifleGrenadeGER );

game/shared/dod/weapon_riflegrenade_ger_live.cpp

@@ -0,0 +1,56 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodbasegrenade.h"
+
+#ifdef CLIENT_DLL
+#define CWeaponRifleGrenadeGER_Live C_WeaponRifleGrenadeGER_Live
+#else 
+#include "dod_riflegrenade_ger.h"	//the thing that we throw
+#endif
+
+
+class CWeaponRifleGrenadeGER_Live : public CWeaponDODBaseGrenade
+{
+public:
+	DECLARE_CLASS( CWeaponRifleGrenadeGER_Live, CWeaponDODBaseGrenade );
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponRifleGrenadeGER_Live() {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_RIFLEGREN_GER_LIVE; }
+
+#ifndef CLIENT_DLL
+
+	virtual void EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer, float flLifeTime = GRENADE_FUSE_LENGTH )
+	{
+		// align the grenade vertically and spin end over end
+		QAngle vecNewAngles = QAngle(45,pPlayer->EyeAngles().y,0);
+		AngularImpulse angNewImpulse = AngularImpulse( 0, 600, 0 );
+
+		CDODRifleGrenadeGER::Create( vecSrc, vecNewAngles, vecVel, angNewImpulse, pPlayer, flLifeTime, GetWeaponID() );
+	}
+
+#endif
+
+	virtual bool IsArmed( void ) { return true; }
+
+private:
+	CWeaponRifleGrenadeGER_Live( const CWeaponRifleGrenadeGER_Live & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponRifleGrenadeGER_Live, DT_WeaponRifleGrenadeGER_Live )
+
+BEGIN_NETWORK_TABLE(CWeaponRifleGrenadeGER_Live, DT_WeaponRifleGrenadeGER_Live)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponRifleGrenadeGER_Live )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_riflegren_ger_live, CWeaponRifleGrenadeGER_Live );
+PRECACHE_WEAPON_REGISTER( weapon_riflegren_ger_live );

game/shared/dod/weapon_riflegrenade_us.cpp

@@ -0,0 +1,91 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_riflegrenade.h"
+
+#if defined( CLIENT_DLL )
+
+	#include "c_dod_player.h"
+	#define CWeaponRifleGrenadeUS C_WeaponRifleGrenadeUS
+
+#else
+
+	#include "dod_riflegrenade_us.h"
+	#include "dod_player.h"
+
+#endif
+
+class CWeaponRifleGrenadeUS : public CWeaponBaseRifleGrenade
+{
+public:
+	DECLARE_CLASS( CWeaponRifleGrenadeUS, CWeaponBaseRifleGrenade );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+
+	CWeaponRifleGrenadeUS()  {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_RIFLEGREN_US; }
+
+#ifndef CLIENT_DLL
+	virtual void EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer, float flLifeTime = GRENADE_FUSE_LENGTH )
+	{
+		CDODRifleGrenadeUS::Create( vecSrc, vecAngles, vecVel, angImpulse, pPlayer, flLifeTime, GetWeaponID() );
+	}
+#endif
+
+	virtual const char *GetCompanionWeaponName( void )
+	{
+		return "weapon_garand";
+	}
+
+private:
+	CWeaponRifleGrenadeUS( const CWeaponRifleGrenadeUS & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponRifleGrenadeUS, DT_WeaponRifleGrenadeUS )
+
+BEGIN_NETWORK_TABLE( CWeaponRifleGrenadeUS, DT_WeaponRifleGrenadeUS )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponRifleGrenadeUS )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_riflegren_us, CWeaponRifleGrenadeUS );
+PRECACHE_WEAPON_REGISTER( weapon_riflegren_us );
+
+acttable_t CWeaponRifleGrenadeUS::m_acttable[] = 
+{
+	{ ACT_DOD_STAND_AIM,					ACT_DOD_STAND_AIM_RIFLE,				false },
+	{ ACT_DOD_CROUCH_AIM,					ACT_DOD_CROUCH_AIM_RIFLE,				false },
+	{ ACT_DOD_CROUCHWALK_AIM,				ACT_DOD_CROUCHWALK_AIM_RIFLE,			false },
+	{ ACT_DOD_WALK_AIM,						ACT_DOD_WALK_AIM_RIFLE,					false },
+	{ ACT_DOD_RUN_AIM,						ACT_DOD_RUN_AIM_RIFLE,					false },
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_RIFLE,				false },
+	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_IDLE_RIFLE,			false },
+	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_IDLE_RIFLE,				false },
+	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_IDLE_RIFLE,				false },
+	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_IDLE_RIFLE,			false },
+	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_IDLE_RIFLE,				false },
+	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_IDLE_RIFLE,					false },
+	{ ACT_SPRINT,							ACT_DOD_SPRINT_IDLE_RIFLE,				false },
+
+	// Attack ( prone? deployed? )
+	{ ACT_RANGE_ATTACK1,					ACT_DOD_PRIMARYATTACK_RIFLE,			false },
+	{ ACT_DOD_PRIMARYATTACK_CROUCH,			ACT_DOD_PRIMARYATTACK_RIFLE,			false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE,			ACT_DOD_PRIMARYATTACK_PRONE_RIFLE,		false },
+
+	{ ACT_RELOAD,							ACT_DOD_RELOAD_RIFLEGRENADE,			false },
+	{ ACT_DOD_RELOAD_CROUCH,				ACT_DOD_RELOAD_CROUCH_RIFLEGRENADE,		false },
+	{ ACT_DOD_RELOAD_PRONE,					ACT_DOD_RELOAD_PRONE_RIFLEGRENADE,		false },
+
+	// Hand Signals
+	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_K98,					false },
+	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_K98,					false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponRifleGrenadeUS );

game/shared/dod/weapon_riflegrenade_us_live.cpp

@@ -0,0 +1,56 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodbasegrenade.h"
+
+#ifdef CLIENT_DLL
+#define CWeaponRifleGrenadeUS_Live C_WeaponRifleGrenadeUS_Live
+#else 
+#include "dod_riflegrenade_us.h"	//the thing that we throw
+#endif
+
+
+class CWeaponRifleGrenadeUS_Live : public CWeaponDODBaseGrenade
+{
+public:
+	DECLARE_CLASS( CWeaponRifleGrenadeUS_Live, CWeaponDODBaseGrenade );
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponRifleGrenadeUS_Live() {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_RIFLEGREN_US_LIVE; }
+
+#ifndef CLIENT_DLL
+
+	virtual void EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer, float flLifeTime = GRENADE_FUSE_LENGTH )
+	{
+		// align the grenade vertically and spin end over end
+		QAngle vecNewAngles = QAngle(45,pPlayer->EyeAngles().y,0);
+		AngularImpulse angNewImpulse = AngularImpulse( 0, 600, 0 );
+
+		CDODRifleGrenadeUS::Create( vecSrc, vecNewAngles, vecVel, angNewImpulse, pPlayer, flLifeTime, GetWeaponID() );
+	}
+
+#endif
+
+	virtual bool IsArmed( void ) { return true; }
+
+private:
+	CWeaponRifleGrenadeUS_Live( const CWeaponRifleGrenadeUS_Live & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponRifleGrenadeUS_Live, DT_WeaponRifleGrenadeUS_Live )
+
+BEGIN_NETWORK_TABLE(CWeaponRifleGrenadeUS_Live, DT_WeaponRifleGrenadeUS_Live)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponRifleGrenadeUS_Live )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_riflegren_us_live, CWeaponRifleGrenadeUS_Live );
+PRECACHE_WEAPON_REGISTER( weapon_riflegren_us_live );

game/shared/dod/weapon_smokegrenade_ger.cpp

@@ -0,0 +1,55 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodbasegrenade.h"
+
+#ifdef CLIENT_DLL
+#define CWeaponSmokeGrenadeGER C_WeaponSmokeGrenadeGER
+#else
+#include "dod_smokegrenade_ger.h"	//the thing that we throw
+#endif
+
+class CWeaponSmokeGrenadeGER : public CWeaponDODBaseGrenade
+{
+public:
+	DECLARE_CLASS( CWeaponSmokeGrenadeGER, CWeaponDODBaseGrenade );
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponSmokeGrenadeGER() {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_SMOKE_GER; }
+
+#ifndef CLIENT_DLL
+
+	virtual void EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer, float flLifeTime = GRENADE_FUSE_LENGTH )
+	{
+		// align the stickgrenade vertically and spin end over end
+		QAngle vecNewAngles = QAngle(45,pPlayer->EyeAngles().y,0);
+		AngularImpulse angNewImpulse = AngularImpulse( 0, 600, 0 );
+
+		CDODSmokeGrenadeGER::Create( vecSrc, vecNewAngles, vecVel, angNewImpulse, pPlayer );
+	}
+
+#endif
+
+	virtual float GetDetonateTimerLength( void ) { return 10; }
+
+private:
+	CWeaponSmokeGrenadeGER( const CWeaponSmokeGrenadeGER & ) {}
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponSmokeGrenadeGER, DT_WeaponSmokeGrenadeGER )
+
+BEGIN_NETWORK_TABLE(CWeaponSmokeGrenadeGER, DT_WeaponSmokeGrenadeGER)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponSmokeGrenadeGER )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_smoke_ger, CWeaponSmokeGrenadeGER );
+PRECACHE_WEAPON_REGISTER( weapon_smoke_ger );

game/shared/dod/weapon_smokegrenade_us.cpp

@@ -0,0 +1,51 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodbasegrenade.h"
+
+#ifdef CLIENT_DLL
+	#define CWeaponSmokeGrenadeUS C_WeaponSmokeGrenadeUS
+#else
+	#include "dod_smokegrenade_us.h"	//the thing that we throw
+#endif
+
+class CWeaponSmokeGrenadeUS : public CWeaponDODBaseGrenade
+{
+public:
+	DECLARE_CLASS( CWeaponSmokeGrenadeUS, CWeaponDODBaseGrenade );
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponSmokeGrenadeUS() {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_SMOKE_US; }
+
+#ifndef CLIENT_DLL
+
+	virtual void EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer, float flLifeTime = GRENADE_FUSE_LENGTH )
+	{
+        CDODSmokeGrenadeUS::Create( vecSrc, vecAngles, vecVel, angImpulse, pPlayer );
+	}
+
+#endif
+
+	virtual float GetDetonateTimerLength( void ) { return 10; }
+
+private:
+	CWeaponSmokeGrenadeUS( const CWeaponSmokeGrenadeUS & ) {}
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponSmokeGrenadeUS, DT_WeaponSmokeGrenadeUS )
+
+BEGIN_NETWORK_TABLE(CWeaponSmokeGrenadeUS, DT_WeaponSmokeGrenadeUS)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponSmokeGrenadeUS )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_smoke_us, CWeaponSmokeGrenadeUS );
+PRECACHE_WEAPON_REGISTER( weapon_smoke_us );

game/shared/dod/weapon_spade.cpp

@@ -0,0 +1,71 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodbasemelee.h"
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponSpade C_WeaponSpade
+
+#endif
+
+
+class CWeaponSpade : public CWeaponDODBaseMelee
+{
+public:
+	DECLARE_CLASS( CWeaponSpade, CWeaponDODBaseMelee );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+	
+	CWeaponSpade()  {}
+
+	virtual Activity GetMeleeActivity( void ) { return ACT_VM_PRIMARYATTACK; }
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_SPADE; }
+
+private:
+	CWeaponSpade( const CWeaponSpade & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponSpade, DT_WeaponSpade )
+
+BEGIN_NETWORK_TABLE( CWeaponSpade, DT_WeaponSpade )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponSpade )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_spade, CWeaponSpade );
+PRECACHE_WEAPON_REGISTER( weapon_spade );
+
+acttable_t CWeaponSpade::m_acttable[] = 
+{
+	{ ACT_DOD_STAND_AIM,					ACT_DOD_STAND_AIM_SPADE,				false },
+	{ ACT_DOD_CROUCH_AIM,					ACT_DOD_CROUCH_AIM_SPADE,				false },
+	{ ACT_DOD_CROUCHWALK_AIM,				ACT_DOD_CROUCHWALK_AIM_SPADE,			false },
+	{ ACT_DOD_WALK_AIM,						ACT_DOD_WALK_AIM_SPADE,					false },
+	{ ACT_DOD_RUN_AIM,						ACT_DOD_RUN_AIM_SPADE,					false },
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_SPADE,				false },
+	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_AIM_SPADE,			false },
+	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_AIM_SPADE,				false },
+	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_AIM_SPADE,				false },
+	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_AIM_SPADE,			false },
+	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_AIM_SPADE,					false },
+	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_AIM_SPADE,					false },
+	{ ACT_SPRINT,							ACT_DOD_SPRINT_AIM_SPADE,				false },
+
+	{ ACT_RANGE_ATTACK2,					ACT_DOD_PRIMARYATTACK_SPADE,			false },
+	{ ACT_DOD_SECONDARYATTACK_CROUCH,		ACT_DOD_PRIMARYATTACK_CROUCH_SPADE,		false },
+	{ ACT_DOD_SECONDARYATTACK_PRONE,		ACT_DOD_PRIMARYATTACK_PRONE_SPADE,		false },
+
+	// Hand Signals
+	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_STICKGRENADE,			false },
+	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_STICKGRENADE,			false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponSpade );

game/shared/dod/weapon_spring.cpp

@@ -0,0 +1,156 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodsniper.h"
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponSpring C_WeaponSpring
+
+#endif
+
+
+class CWeaponSpring : public CDODSniperWeapon
+{
+public:
+	DECLARE_CLASS( CWeaponSpring, CDODSniperWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+	
+	CWeaponSpring()  {}
+
+	virtual void Spawn( void );
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_SPRING; }
+
+	// weapon id for stats purposes
+	virtual DODWeaponID GetStatsWeaponID( void )
+	{
+		if ( IsFullyZoomed() )
+			return WEAPON_SPRING_ZOOMED;
+		else 
+			return WEAPON_SPRING;
+	}
+
+	virtual bool ShouldAutoEjectBrass( void ) { return false; }
+	virtual bool ShouldDrawCrosshair( void ) { return false; }
+
+	virtual bool ShouldDrawViewModel( void )
+	{
+		CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
+
+		Assert( pPlayer );
+
+		if ( !pPlayer )
+			return false;
+
+		if ( pPlayer->GetFOV() < 90 )
+			return false;
+
+		// handle case when we are spectating someone and don't know their fov
+		if ( IsFullyZoomed() )
+			return false;
+
+		return BaseClass::ShouldDrawViewModel();
+	}
+
+	virtual bool ShouldDrawMuzzleFlash( void )
+	{
+		return ShouldDrawViewModel();
+	}
+
+	virtual Activity GetPrimaryAttackActivity( void	);
+
+	virtual float GetFireDelay( void );
+
+	virtual float GetRecoil( void ) { return 5.6f; }
+
+private:
+	CWeaponSpring( const CWeaponSpring & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponSpring, DT_WeaponSpring )
+
+BEGIN_NETWORK_TABLE( CWeaponSpring, DT_WeaponSpring )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponSpring )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_spring, CWeaponSpring );
+PRECACHE_WEAPON_REGISTER( weapon_spring );
+
+void CWeaponSpring::Spawn( void )
+{
+	m_iAltFireHint = HINT_USE_ZOOM;
+
+	BaseClass::Spawn();
+}
+
+acttable_t CWeaponSpring::m_acttable[] = 
+{
+	{ ACT_DOD_STAND_AIM,					ACT_DOD_STAND_AIM_BOLT,					false },
+	{ ACT_DOD_CROUCH_AIM,					ACT_DOD_CROUCH_AIM_BOLT,				false },
+	{ ACT_DOD_CROUCHWALK_AIM,				ACT_DOD_CROUCHWALK_AIM_BOLT,			false },
+	{ ACT_DOD_WALK_AIM,						ACT_DOD_WALK_AIM_BOLT,					false },
+	{ ACT_DOD_RUN_AIM,						ACT_DOD_RUN_AIM_BOLT,					false },
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_BOLT,					false },
+	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_IDLE_BOLT,			false },
+	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_IDLE_BOLT,				false },
+	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_IDLE_BOLT,				false },
+	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_IDLE_BOLT,			false },
+	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_IDLE_BOLT,					false },
+	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_IDLE_BOLT,					false },
+	{ ACT_SPRINT,							ACT_DOD_SPRINT_IDLE_BOLT,				false },
+
+	// Zoomed Aim
+	{ ACT_DOD_IDLE_ZOOMED,					ACT_DOD_STAND_ZOOM_BOLT,				false },
+	{ ACT_DOD_CROUCH_ZOOMED,				ACT_DOD_CROUCH_ZOOM_BOLT,				false },
+	{ ACT_DOD_CROUCHWALK_ZOOMED,			ACT_DOD_CROUCHWALK_ZOOM_BOLT,			false },
+	{ ACT_DOD_WALK_ZOOMED,					ACT_DOD_WALK_ZOOM_BOLT,					false },
+	{ ACT_DOD_PRONE_ZOOMED,					ACT_DOD_PRONE_ZOOM_BOLT,				false },
+	{ ACT_DOD_PRONE_FORWARD_ZOOMED,			ACT_DOD_PRONE_ZOOM_FORWARD_BOLT,		false },
+
+	// Attack ( prone? )
+	{ ACT_RANGE_ATTACK1,					ACT_DOD_PRIMARYATTACK_BOLT,				false },
+	{ ACT_DOD_PRIMARYATTACK_CROUCH,			ACT_DOD_PRIMARYATTACK_BOLT,				false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE,			ACT_DOD_PRIMARYATTACK_PRONE_BOLT,		false },
+
+	// Reload ( prone ? )
+	{ ACT_RELOAD,							ACT_DOD_RELOAD_BOLT,					false },
+	{ ACT_DOD_RELOAD_CROUCH,				ACT_DOD_RELOAD_CROUCH_BOLT,				false },
+	{ ACT_DOD_RELOAD_PRONE,					ACT_DOD_RELOAD_PRONE_BOLT,				false },
+
+	// Hand Signals
+	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_K98,					false },
+	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_K98,					false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponSpring );
+
+Activity CWeaponSpring::GetPrimaryAttackActivity( void )
+{
+	Activity actPrim;
+
+	if( m_iClip1 <= 0 )
+		actPrim = ACT_VM_PRIMARYATTACK_EMPTY;	
+	else
+		actPrim = ACT_VM_PRIMARYATTACK;
+
+	return actPrim;
+}
+
+float CWeaponSpring::GetFireDelay( void )
+{
+	if ( m_iClip1 <= 0 )
+	{
+		return SequenceDuration();
+	}
+
+	return BaseClass::GetFireDelay();
+}

game/shared/dod/weapon_stickgrenade.cpp

@@ -0,0 +1,82 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodbasegrenade.h"
+
+#ifdef CLIENT_DLL
+	#define CWeaponStickGrenade C_WeaponStickGrenade
+#else
+	#include "dod_stickgrenade.h"
+#endif
+
+class CWeaponStickGrenade : public CWeaponDODBaseGrenade
+{
+public:
+	DECLARE_CLASS( CWeaponStickGrenade, CWeaponDODBaseGrenade );
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+
+	CWeaponStickGrenade() {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_FRAG_GER; }
+
+#ifndef CLIENT_DLL
+
+	virtual void EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer, float flLifeTime = GRENADE_FUSE_LENGTH )
+	{
+		// align the stickgrenade vertically and spin end over end
+		QAngle vecNewAngles = QAngle(45,pPlayer->EyeAngles().y,0);
+		AngularImpulse angNewImpulse = AngularImpulse( 0, 600, 0 );
+
+		CDODStickGrenade::Create( vecSrc, vecNewAngles, vecVel, angNewImpulse, pPlayer, flLifeTime, GetWeaponID() );
+	}
+
+#endif
+
+	CWeaponStickGrenade( const CWeaponStickGrenade & ) {}
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponStickGrenade, DT_WeaponStickGrenade )
+
+BEGIN_NETWORK_TABLE(CWeaponStickGrenade, DT_WeaponStickGrenade)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponStickGrenade )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_frag_ger, CWeaponStickGrenade );
+PRECACHE_WEAPON_REGISTER( weapon_frag_ger );
+
+acttable_t CWeaponStickGrenade::m_acttable[] = 
+{
+	// Move this out to the specific grenades???
+	{ ACT_DOD_STAND_AIM,					ACT_DOD_STAND_AIM_GREN_STICK,				false },
+	{ ACT_DOD_CROUCH_AIM,					ACT_DOD_CROUCH_AIM_GREN_STICK,				false },
+	{ ACT_DOD_CROUCHWALK_AIM,				ACT_DOD_CROUCHWALK_AIM_GREN_STICK,			false },
+	{ ACT_DOD_WALK_AIM,						ACT_DOD_WALK_AIM_GREN_STICK,				false },
+	{ ACT_DOD_RUN_AIM,						ACT_DOD_RUN_AIM_GREN_STICK,					false },
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_GREN_STICK,				false },
+	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_AIM_GREN_STICK,			false },
+	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_AIM_GREN_STICK,				false },
+	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_AIM_GREN_STICK,				false },
+	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_AIM_GREN_STICK,			false },
+	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_AIM_GREN_STICK,				false },
+	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_AIM_GREN_STICK,					false },
+	{ ACT_SPRINT,							ACT_DOD_SPRINT_AIM_GREN_STICK,				false },
+
+	{ ACT_RANGE_ATTACK1,				ACT_DOD_PRIMARYATTACK_GREN_STICK,		false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE,		ACT_DOD_PRIMARYATTACK_PRONE_GREN_STICK,	false },
+	{ ACT_DOD_PRIMARYATTACK_CROUCH,		ACT_DOD_PRIMARYATTACK_CROUCH_GREN_STICK, false },
+
+	// Hand Signals
+	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_STICKGRENADE,			false },
+	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_STICKGRENADE,			false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponStickGrenade );
+

game/shared/dod/weapon_thompson.cpp

@@ -0,0 +1,81 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_dodfullauto_punch.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponThompson C_WeaponThompson
+
+#endif
+
+
+class CWeaponThompson : public CDODFullAutoPunchWeapon
+{
+public:
+	DECLARE_CLASS( CWeaponThompson, CDODFullAutoPunchWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	DECLARE_ACTTABLE();
+	
+	CWeaponThompson()  {}
+
+	virtual DODWeaponID GetWeaponID( void ) const		{ return WEAPON_THOMPSON; }
+	virtual DODWeaponID GetAltWeaponID( void ) const	{ return WEAPON_THOMPSON_PUNCH; }
+
+	virtual float GetRecoil( void ) { return 2.15f; }
+
+private:
+	CWeaponThompson( const CWeaponThompson & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponThompson, DT_WeaponThompson )
+
+BEGIN_NETWORK_TABLE( CWeaponThompson, DT_WeaponThompson )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponThompson )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_thompson, CWeaponThompson );
+PRECACHE_WEAPON_REGISTER( weapon_thompson );
+
+acttable_t CWeaponThompson::m_acttable[] = 
+{
+	{ ACT_DOD_STAND_AIM,					ACT_DOD_STAND_AIM_TOMMY,				false },
+	{ ACT_DOD_CROUCH_AIM,					ACT_DOD_CROUCH_AIM_TOMMY,				false },
+	{ ACT_DOD_CROUCHWALK_AIM,				ACT_DOD_CROUCHWALK_AIM_TOMMY,			false },
+	{ ACT_DOD_WALK_AIM,						ACT_DOD_WALK_AIM_TOMMY,					false },
+	{ ACT_DOD_RUN_AIM,						ACT_DOD_RUN_AIM_TOMMY,					false },
+	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_TOMMY,				false },
+	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_IDLE_TOMMY,			false },
+	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_IDLE_TOMMY,				false },
+	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_IDLE_TOMMY,				false },
+	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_IDLE_TOMMY,			false },
+	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_IDLE_TOMMY,				false },
+	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_IDLE_TOMMY,					false },
+	{ ACT_SPRINT,							ACT_DOD_SPRINT_IDLE_TOMMY,				false },
+
+	{ ACT_RANGE_ATTACK1,					ACT_DOD_PRIMARYATTACK_TOMMY,			false },
+	{ ACT_DOD_PRIMARYATTACK_CROUCH,			ACT_DOD_PRIMARYATTACK_TOMMY,			false },
+	{ ACT_DOD_PRIMARYATTACK_PRONE,			ACT_DOD_PRIMARYATTACK_PRONE_TOMMY,		false },
+	{ ACT_RANGE_ATTACK2,					ACT_DOD_SECONDARYATTACK_TOMMY,			false },
+	{ ACT_DOD_SECONDARYATTACK_CROUCH,		ACT_DOD_SECONDARYATTACK_CROUCH_TOMMY,	false },
+	{ ACT_DOD_SECONDARYATTACK_PRONE,		ACT_DOD_SECONDARYATTACK_PRONE_TOMMY,	false },
+
+	{ ACT_RELOAD,							ACT_DOD_RELOAD_TOMMY,					false },
+	{ ACT_DOD_RELOAD_CROUCH,				ACT_DOD_RELOAD_CROUCH_TOMMY,			false },
+	{ ACT_DOD_RELOAD_PRONE,					ACT_DOD_RELOAD_PRONE_TOMMY,				false },
+
+	// Hand Signals
+	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_TOMMY,				false },
+	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_TOMMY,			false },
+};
+
+IMPLEMENT_ACTTABLE( CWeaponThompson );
+