add hl1,portal,dod source code

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 );
+

game/shared/hl1/hl1_basecombatweapon_shared.cpp

@@ -0,0 +1,230 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "hl1_basecombatweapon_shared.h"
+
+#include "hl1_player_shared.h"
+
+LINK_ENTITY_TO_CLASS( basehl1combatweapon, CBaseHL1CombatWeapon );
+
+IMPLEMENT_NETWORKCLASS_ALIASED( BaseHL1CombatWeapon , DT_BaseHL1CombatWeapon )
+
+BEGIN_NETWORK_TABLE( CBaseHL1CombatWeapon , DT_BaseHL1CombatWeapon )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CBaseHL1CombatWeapon )
+END_PREDICTION_DATA()
+
+
+void CBaseHL1CombatWeapon::Spawn( void )
+{
+	Precache();
+
+	SetSolid( SOLID_BBOX );
+	m_flNextEmptySoundTime = 0.0f;
+
+	// Weapons won't show up in trace calls if they are being carried...
+	RemoveEFlags( EFL_USE_PARTITION_WHEN_NOT_SOLID );
+
+	m_iState = WEAPON_NOT_CARRIED;
+	// Assume 
+	m_nViewModelIndex = 0;
+
+	// If I use clips, set my clips to the default
+	if ( UsesClipsForAmmo1() )
+	{
+		m_iClip1 = GetDefaultClip1();
+	}
+	else
+	{
+		SetPrimaryAmmoCount( GetDefaultClip1() );
+		m_iClip1 = WEAPON_NOCLIP;
+	}
+	if ( UsesClipsForAmmo2() )
+	{
+		m_iClip2 = GetDefaultClip2();
+	}
+	else
+	{
+		SetSecondaryAmmoCount( GetDefaultClip2() );
+		m_iClip2 = WEAPON_NOCLIP;
+	}
+
+	SetModel( GetWorldModel() );
+
+#if !defined( CLIENT_DLL )
+	FallInit();
+	SetCollisionGroup( COLLISION_GROUP_WEAPON );
+
+	m_takedamage = DAMAGE_EVENTS_ONLY;
+
+	SetBlocksLOS( false );
+
+	// Default to non-removeable, because we don't want the
+	// game_weapon_manager entity to remove weapons that have
+	// been hand-placed by level designers. We only want to remove
+	// weapons that have been dropped by NPC's.
+	SetRemoveable( false );
+#endif
+
+	//Make weapons easier to pick up in MP.
+	if ( g_pGameRules->IsMultiplayer() )
+	{
+		CollisionProp()->UseTriggerBounds( true, 36 );
+	}
+	else
+	{
+		CollisionProp()->UseTriggerBounds( true, 24 );
+	}
+
+	// Use more efficient bbox culling on the client. Otherwise, it'll setup bones for most
+	// characters even when they're not in the frustum.
+	AddEffects( EF_BONEMERGE_FASTCULL );
+}
+
+#if defined( CLIENT_DLL )
+
+#define	HL1_BOB_CYCLE_MIN	1.0f
+#define	HL1_BOB_CYCLE_MAX	0.45f
+#define	HL1_BOB			0.002f
+#define	HL1_BOB_UP		0.5f
+
+float	g_lateralBob;
+float	g_verticalBob;
+
+static ConVar	cl_bobcycle( "cl_bobcycle","0.8" );
+static ConVar	cl_bob( "cl_bob","0.002" );
+static ConVar	cl_bobup( "cl_bobup","0.5" );
+
+// Register these cvars if needed for easy tweaking
+static ConVar	v_iyaw_cycle( "v_iyaw_cycle", "2"/*, FCVAR_UNREGISTERED*/ );
+static ConVar	v_iroll_cycle( "v_iroll_cycle", "0.5"/*, FCVAR_UNREGISTERED*/ );
+static ConVar	v_ipitch_cycle( "v_ipitch_cycle", "1"/*, FCVAR_UNREGISTERED*/ );
+static ConVar	v_iyaw_level( "v_iyaw_level", "0.3"/*, FCVAR_UNREGISTERED*/ );
+static ConVar	v_iroll_level( "v_iroll_level", "0.1"/*, FCVAR_UNREGISTERED*/ );
+static ConVar	v_ipitch_level( "v_ipitch_level", "0.3"/*, FCVAR_UNREGISTERED*/ );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : float
+//-----------------------------------------------------------------------------
+float CBaseHL1CombatWeapon::CalcViewmodelBob( void )
+{
+	static	float bobtime;
+	static	float lastbobtime;
+	float	cycle;
+	
+	CBasePlayer *player = ToBasePlayer( GetOwner() );
+	//Assert( player );
+
+	//NOTENOTE: For now, let this cycle continue when in the air, because it snaps badly without it
+
+	if ( ( !gpGlobals->frametime ) || ( player == NULL ) )
+	{
+		//NOTENOTE: We don't use this return value in our case (need to restructure the calculation function setup!)
+		return 0.0f;// just use old value
+	}
+
+	//Find the speed of the player
+	float speed = player->GetLocalVelocity().Length2D();
+
+	//FIXME: This maximum speed value must come from the server.
+	//		 MaxSpeed() is not sufficient for dealing with sprinting - jdw
+
+	speed = clamp( speed, -320, 320 );
+
+	float bob_offset = RemapVal( speed, 0, 320, 0.0f, 1.0f );
+	
+	bobtime += ( gpGlobals->curtime - lastbobtime ) * bob_offset;
+	lastbobtime = gpGlobals->curtime;
+
+	//Calculate the vertical bob
+	cycle = bobtime - (int)(bobtime/HL1_BOB_CYCLE_MAX)*HL1_BOB_CYCLE_MAX;
+	cycle /= HL1_BOB_CYCLE_MAX;
+
+	if ( cycle < HL1_BOB_UP )
+	{
+		cycle = M_PI * cycle / HL1_BOB_UP;
+	}
+	else
+	{
+		cycle = M_PI + M_PI*(cycle-HL1_BOB_UP)/(1.0 - HL1_BOB_UP);
+	}
+	
+	g_verticalBob = speed*0.005f;
+	g_verticalBob = g_verticalBob*0.3 + g_verticalBob*0.7*sin(cycle);
+
+	g_verticalBob = clamp( g_verticalBob, -7.0f, 4.0f );
+
+	//Calculate the lateral bob
+	cycle = bobtime - (int)(bobtime/HL1_BOB_CYCLE_MAX*2)*HL1_BOB_CYCLE_MAX*2;
+	cycle /= HL1_BOB_CYCLE_MAX*2;
+
+	if ( cycle < HL1_BOB_UP )
+	{
+		cycle = M_PI * cycle / HL1_BOB_UP;
+	}
+	else
+	{
+		cycle = M_PI + M_PI*(cycle-HL1_BOB_UP)/(1.0 - HL1_BOB_UP);
+	}
+
+	g_lateralBob = speed*0.005f;
+	g_lateralBob = g_lateralBob*0.3 + g_lateralBob*0.7*sin(cycle);
+	g_lateralBob = clamp( g_lateralBob, -7.0f, 4.0f );
+	
+	//NOTENOTE: We don't use this return value in our case (need to restructure the calculation function setup!)
+	return 0.0f;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : &origin - 
+//			&angles - 
+//			viewmodelindex - 
+//-----------------------------------------------------------------------------
+void CBaseHL1CombatWeapon::AddViewmodelBob( CBaseViewModel *viewmodel, Vector &origin, QAngle &angles )
+{
+	Vector	forward, right;
+	AngleVectors( angles, &forward, &right, NULL );
+
+	CalcViewmodelBob();
+
+	// Apply bob, but scaled down to 40%
+	VectorMA( origin, g_verticalBob * 0.1f, forward, origin );
+	
+	// Z bob a bit more
+	origin[2] += g_verticalBob * 0.1f;
+	
+	// bob the angles
+	angles[ ROLL ]	+= g_verticalBob * 0.5f;
+	angles[ PITCH ]	-= g_verticalBob * 0.4f;
+
+	angles[ YAW ]	-= g_lateralBob  * 0.3f;
+
+	VectorMA( origin, g_lateralBob * 0.8f, right, origin );
+}
+
+
+#else
+
+Vector CBaseHL1CombatWeapon::GetSoundEmissionOrigin() const
+{
+	if ( gpGlobals->maxClients == 1 || !GetOwner() )
+		return CBaseCombatWeapon::GetSoundEmissionOrigin();
+
+//	Vector vecOwner = GetOwner()->GetSoundEmissionOrigin();
+//	Vector vecThis = WorldSpaceCenter();
+//	DevMsg("SoundEmissionOrigin: Owner: %4.1f,%4.1f,%4.1f Default:%4.1f,%4.1f,%4.1f\n",
+//			vecOwner.x, vecOwner.y, vecOwner.z,
+//			vecThis.x, vecThis.y, vecThis.z );
+
+	// TEMP fix for HL1MP... sounds are sometimes beeing emitted underneath the ground
+	return GetOwner()->GetSoundEmissionOrigin();
+}
+
+#endif

game/shared/hl1/hl1_basecombatweapon_shared.h

@@ -0,0 +1,50 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "basecombatweapon_shared.h"
+
+#ifndef BASEHLCOMBATWEAPON_SHARED_H
+#define BASEHLCOMBATWEAPON_SHARED_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#if defined( CLIENT_DLL )
+#define CBaseHL1CombatWeapon C_BaseHL1CombatWeapon
+#endif
+
+class CBaseHL1CombatWeapon : public CBaseCombatWeapon
+{
+	DECLARE_CLASS( CBaseHL1CombatWeapon, CBaseCombatWeapon );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+public:
+	void Spawn( void );
+
+public:
+// Server Only Methods
+#if !defined( CLIENT_DLL )
+	DECLARE_DATADESC();
+
+	virtual void Precache();
+
+	void FallInit( void );						// prepare to fall to the ground
+	virtual void FallThink( void );						// make the weapon fall to the ground after spawning
+
+	void EjectShell( CBaseEntity *pPlayer, int iType );
+
+	Vector GetSoundEmissionOrigin() const;
+#else
+
+	virtual void	AddViewmodelBob( CBaseViewModel *viewmodel, Vector &origin, QAngle &angles );
+	virtual	float	CalcViewmodelBob( void );
+
+#endif
+};
+
+#endif // BASEHLCOMBATWEAPON_SHARED_H

game/shared/hl1/hl1_gamemovement.cpp

@@ -0,0 +1,305 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+//========= Copyright © 1996-2001, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+#include "cbase.h"
+#include "gamemovement.h"
+#include "in_buttons.h"
+#include <stdarg.h>
+#include "movevars_shared.h"
+#include "engine/IEngineTrace.h"
+#include "SoundEmitterSystem/isoundemittersystembase.h"
+#include "decals.h"
+#include "tier0/vprof.h"
+#include "hl1_gamemovement.h"
+
+
+// Expose our interface.
+static CHL1GameMovement g_GameMovement;
+IGameMovement *g_pGameMovement = ( IGameMovement * )&g_GameMovement;
+
+EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CGameMovement, IGameMovement, INTERFACENAME_GAMEMOVEMENT, g_GameMovement );
+
+#ifdef CLIENT_DLL
+#include "hl1/c_hl1mp_player.h"
+#else
+#include "hl1mp_player.h"
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CHL1GameMovement::CheckJumpButton( void )
+{
+	m_pHL1Player = ToHL1Player( player );
+
+	Assert( m_pHL1Player );
+
+	if (m_pHL1Player->pl.deadflag)
+	{
+		mv->m_nOldButtons |= IN_JUMP ;	// don't jump again until released
+		return false;
+	}
+
+	// See if we are waterjumping.  If so, decrement count and return.
+	if (m_pHL1Player->m_flWaterJumpTime)
+	{
+		m_pHL1Player->m_flWaterJumpTime -= gpGlobals->frametime;
+		if (m_pHL1Player->m_flWaterJumpTime < 0)
+			m_pHL1Player->m_flWaterJumpTime = 0;
+		
+		return false;
+	}
+
+	// If we are in the water most of the way...
+	if ( m_pHL1Player->GetWaterLevel() >= 2 )
+	{	
+		// swimming, not jumping
+		SetGroundEntity( NULL );
+
+		if(m_pHL1Player->GetWaterType() == CONTENTS_WATER)    // We move up a certain amount
+			mv->m_vecVelocity[2] = 100;
+		else if (m_pHL1Player->GetWaterType() == CONTENTS_SLIME)
+			mv->m_vecVelocity[2] = 80;
+		
+		// play swiming sound
+		if ( m_pHL1Player->m_flSwimSoundTime <= 0 )
+		{
+			// Don't play sound again for 1 second
+			m_pHL1Player->m_flSwimSoundTime = 1000;
+			PlaySwimSound();
+		}
+
+		return false;
+	}
+
+	// No more effect
+ 	if (m_pHL1Player->GetGroundEntity() == NULL)
+	{
+		mv->m_nOldButtons |= IN_JUMP;
+		return false;		// in air, so no effect
+	}
+
+	if ( mv->m_nOldButtons & IN_JUMP )
+		return false;		// don't pogo stick
+
+	// In the air now.
+	SetGroundEntity( NULL );
+	
+	m_pHL1Player->PlayStepSound( (Vector &)mv->GetAbsOrigin(), player->GetSurfaceData(), 1.0, true );
+	
+	MoveHelper()->PlayerSetAnimation( PLAYER_JUMP );
+
+	float flGroundFactor = 1.0f;
+	if ( player->GetSurfaceData() )
+	{
+		flGroundFactor = 1.0;//player->GetSurfaceData()->game.jumpFactor; 
+	}
+
+	// Acclerate upward
+	// If we are ducking...
+	float startz = mv->m_vecVelocity[2];
+	if ( (  m_pHL1Player->m_Local.m_bDucking ) || (  m_pHL1Player->GetFlags() & FL_DUCKING ) )
+	{
+		// d = 0.5 * g * t^2		- distance traveled with linear accel
+		// t = sqrt(2.0 * 45 / g)	- how long to fall 45 units
+		// v = g * t				- velocity at the end (just invert it to jump up that high)
+		// v = g * sqrt(2.0 * 45 / g )
+		// v^2 = g * g * 2.0 * 45 / g
+		// v = sqrt( g * 2.0 * 45 )
+		
+		// Adjust for super long jump module
+		// UNDONE -- note this should be based on forward angles, not current velocity.
+		if ( m_pHL1Player->m_bHasLongJump &&
+			( mv->m_nButtons & IN_DUCK ) &&
+			( m_pHL1Player->m_Local.m_flDucktime > 0 ) &&
+			mv->m_vecVelocity.Length() > 50 )
+		{
+			m_pHL1Player->m_Local.m_vecPunchAngle.Set( PITCH, -5 );
+
+			mv->m_vecVelocity = m_vecForward * PLAYER_LONGJUMP_SPEED * 1.6;
+			mv->m_vecVelocity.z = sqrt(2 * 800 * 56.0);
+		}
+		else
+		{
+			mv->m_vecVelocity[2] = flGroundFactor * sqrt(2 * 800 * 45.0);  // 2 * gravity * height
+		}
+	}
+	else
+	{
+		mv->m_vecVelocity[2] += flGroundFactor * sqrt(2 * 800 * 45.0);  // 2 * gravity * height
+	}
+	FinishGravity();
+
+	mv->m_outWishVel.z += mv->m_vecVelocity[2] - startz;
+	mv->m_outStepHeight += 0.1f;
+	
+	if ( gpGlobals->maxClients > 1 )
+#ifdef CLIENT_DLL
+		(dynamic_cast<C_HL1MP_Player*>(m_pHL1Player))->DoAnimationEvent( PLAYERANIMEVENT_JUMP );
+#else
+		(dynamic_cast<CHL1MP_Player*>(m_pHL1Player))->DoAnimationEvent( PLAYERANIMEVENT_JUMP );
+#endif
+
+	// Flag that we jumped.
+	mv->m_nOldButtons |= IN_JUMP;	// don't jump again until released
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: See if duck button is pressed and do the appropriate things
+//-----------------------------------------------------------------------------
+void CHL1GameMovement::Duck( void )
+{
+	int buttonsChanged	= ( mv->m_nOldButtons ^ mv->m_nButtons );	// These buttons have changed this frame
+	int buttonsPressed	=  buttonsChanged & mv->m_nButtons;			// The changed ones still down are "pressed"
+	int buttonsReleased	=  buttonsChanged & mv->m_nOldButtons;		// The changed ones which were previously down are "released"
+
+	// Check to see if we are in the air.
+	bool bInAir = ( player->GetGroundEntity() == NULL );
+	bool bInDuck = ( player->GetFlags() & FL_DUCKING ) ? true : false;
+
+	if ( mv->m_nButtons & IN_DUCK )
+	{
+		mv->m_nOldButtons |= IN_DUCK;
+	}
+	else
+	{
+		mv->m_nOldButtons &= ~IN_DUCK;
+	}
+
+	// Handle death.
+	if ( IsDead() )
+	{
+		if ( bInDuck )
+		{
+			// Unduck
+			FinishUnDuck();
+		}
+		return;
+	}
+
+	HandleDuckingSpeedCrop();
+
+	// If the player is holding down the duck button, the player is in duck transition, ducking, or duck-jumping.
+	if ( ( mv->m_nButtons & IN_DUCK ) || player->m_Local.m_bDucking  || bInDuck )
+	{
+		if ( ( mv->m_nButtons & IN_DUCK ) )
+		{
+			// Have the duck button pressed, but the player currently isn't in the duck position.
+			if ( ( buttonsPressed & IN_DUCK ) && !bInDuck )
+			{
+				// Use 1 second so super long jump will work
+				player->m_Local.m_flDucktime = GAMEMOVEMENT_DUCK_TIME;
+				player->m_Local.m_bDucking    = true;
+			}
+
+			// The player is in duck transition and not duck-jumping.
+			if ( player->m_Local.m_bDucking )
+			{
+				float flDuckMilliseconds = MAX( 0.0f, GAMEMOVEMENT_DUCK_TIME - ( float )player->m_Local.m_flDucktime );
+				float flDuckSeconds = flDuckMilliseconds / GAMEMOVEMENT_DUCK_TIME;
+				
+				// Finish in duck transition when transition time is over, in "duck", in air.
+				if ( ( flDuckSeconds > TIME_TO_DUCK ) || bInDuck || bInAir )
+				{
+					FinishDuck();
+				}
+				else
+				{
+					// Calc parametric time
+					float flDuckFraction = SimpleSpline( flDuckSeconds / TIME_TO_DUCK );
+					SetDuckedEyeOffset( flDuckFraction );
+				}
+			}
+		}
+		else
+		{
+			// Try to unduck unless automovement is not allowed
+			// NOTE: When not onground, you can always unduck
+			if ( player->m_Local.m_bAllowAutoMovement || bInAir )
+			{
+				if ( ( buttonsReleased & IN_DUCK ) && bInDuck )
+				{
+					// Use 1 second so super long jump will work
+					player->m_Local.m_flDucktime = GAMEMOVEMENT_DUCK_TIME;
+				}
+
+				// Check to see if we are capable of unducking.
+				if ( CanUnduck() )
+				{
+					// or unducking
+  					if ( ( player->m_Local.m_bDucking || player->m_Local.m_bDucked ) )
+					{
+						float flDuckMilliseconds = MAX( 0.0f, GAMEMOVEMENT_DUCK_TIME - (float)player->m_Local.m_flDucktime );
+						float flDuckSeconds = flDuckMilliseconds / GAMEMOVEMENT_DUCK_TIME;
+						
+						// Finish ducking immediately if duck time is over or not on ground
+						if ( flDuckSeconds > TIME_TO_UNDUCK || ( bInAir ) )
+						{
+							FinishUnDuck();
+						}
+						else
+						{
+							// Calc parametric time
+							float flDuckFraction = SimpleSpline( 1.0f - ( flDuckSeconds / TIME_TO_UNDUCK ) );
+							SetDuckedEyeOffset( flDuckFraction );
+							player->m_Local.m_bDucking = true;
+						}
+					}
+				}
+				else
+				{
+					// Still under something where we can't unduck, so make sure we reset this timer so
+					//  that we'll unduck once we exit the tunnel, etc.
+					player->m_Local.m_flDucktime = GAMEMOVEMENT_DUCK_TIME;
+					SetDuckedEyeOffset( 1.0f );
+				}
+			}
+		}
+	}
+}
+
+void CHL1GameMovement::HandleDuckingSpeedCrop()
+{
+	if ( !( m_iSpeedCropped & SPEED_CROPPED_DUCK ) )
+	{
+		if ( player->GetFlags() & FL_DUCKING )
+		{
+			float frac = 0.33333333f;
+			mv->m_flForwardMove	*= frac;
+			mv->m_flSideMove	*= frac;
+			mv->m_flUpMove		*= frac;
+			m_iSpeedCropped		|= SPEED_CROPPED_DUCK;
+		}
+	}
+}
+
+void CHL1GameMovement::CheckParameters( void )
+{
+	if ( mv->m_nButtons & IN_SPEED )
+	{
+		mv->m_flClientMaxSpeed = 100;
+	}
+	else
+	{
+		mv->m_flClientMaxSpeed = mv->m_flMaxSpeed;
+	}
+
+	CHL1_Player* pHL1Player = dynamic_cast<CHL1_Player*>(player);
+	if( pHL1Player && pHL1Player->IsPullingObject() )
+	{
+		mv->m_flClientMaxSpeed = mv->m_flMaxSpeed * 0.5f;
+	}
+
+	BaseClass::CheckParameters();
+}

game/shared/hl1/hl1_gamemovement.h

@@ -0,0 +1,42 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef C_HL1_GAMEMOVEMENT_H
+#define C_HL1_GAMEMOVEMENT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#ifdef CLIENT_DLL
+	#include "hl1/hl1_c_player.h"
+#else
+	#include "hl1_player.h"
+#endif
+
+#if defined( CLIENT_DLL )
+	class CHL1_Player;
+	#define CHL1_Player C_HL1_Player
+#endif
+
+#define PLAYER_LONGJUMP_SPEED 350 // how fast we longjump
+
+class CHL1GameMovement : public CGameMovement
+{
+public:
+	DECLARE_CLASS( CHL1GameMovement, CGameMovement );
+
+	virtual bool CheckJumpButton( void );
+
+	// Duck
+	virtual void Duck( void );
+	virtual void HandleDuckingSpeedCrop();
+	virtual void CheckParameters( void );
+
+protected:
+	CHL1_Player *m_pHL1Player;
+};
+
+#endif //C_HL1_GAMEMOVEMENT_H

game/shared/hl1/hl1_gamerules.cpp

@@ -0,0 +1,741 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: The Half-Life 1 game rules, such as the relationship tables and ammo
+//			damage cvars.
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "hl1_gamerules.h"
+#include "ammodef.h"
+
+
+#ifdef CLIENT_DLL
+
+#else
+
+	#include "player.h"
+	#include "game.h"
+	#include "gamerules.h"
+	#include "teamplay_gamerules.h"
+	#include "hl1_player.h"
+	#include "voice_gamemgr.h"
+	#include "hl1mp_weapon_satchel.h"
+#endif
+
+
+REGISTER_GAMERULES_CLASS( CHalfLife1 );
+
+
+ConVar sk_plr_dmg_crowbar			( "sk_plr_dmg_crowbar",			"0", FCVAR_REPLICATED );
+
+ConVar sk_npc_dmg_9mm_bullet		( "sk_npc_dmg_9mm_bullet",		"0", FCVAR_REPLICATED );
+ConVar sk_plr_dmg_9mm_bullet		( "sk_plr_dmg_9mm_bullet",		"0", FCVAR_REPLICATED );
+ConVar sk_max_9mm_bullet			( "sk_max_9mm_bullet",			"0", FCVAR_REPLICATED );
+
+ConVar sk_npc_dmg_9mmAR_bullet		( "sk_npc_dmg_9mmAR_bullet",	"0", FCVAR_REPLICATED );
+
+ConVar sk_plr_dmg_357_bullet		( "sk_plr_dmg_357_bullet",		"0", FCVAR_REPLICATED );
+ConVar sk_max_357_bullet			( "sk_max_357_bullet",			"0", FCVAR_REPLICATED );
+
+ConVar sk_plr_dmg_buckshot			( "sk_plr_dmg_buckshot",		"0", FCVAR_REPLICATED );
+ConVar sk_max_buckshot				( "sk_max_buckshot",			"0", FCVAR_REPLICATED );
+
+ConVar sk_plr_dmg_mp5_grenade		( "sk_plr_dmg_mp5_grenade",		"0", FCVAR_REPLICATED );
+ConVar sk_max_mp5_grenade			( "sk_max_mp5_grenade",			"0", FCVAR_REPLICATED );
+ConVar sk_mp5_grenade_radius		( "sk_mp5_grenade_radius",		"0", FCVAR_REPLICATED );
+
+ConVar sk_plr_dmg_rpg				( "sk_plr_dmg_rpg",				"0", FCVAR_REPLICATED );
+ConVar sk_max_rpg_rocket			( "sk_max_rpg_rocket",			"0", FCVAR_REPLICATED );
+
+ConVar sk_plr_dmg_xbow_bolt_plr		( "sk_plr_dmg_xbow_bolt_plr",	"0", FCVAR_REPLICATED );
+ConVar sk_plr_dmg_xbow_bolt_npc		( "sk_plr_dmg_xbow_bolt_npc",	"0", FCVAR_REPLICATED );
+ConVar sk_max_xbow_bolt				( "sk_max_xbow_bolt",			"0", FCVAR_REPLICATED );
+
+ConVar sk_plr_dmg_egon_narrow		( "sk_plr_dmg_egon_narrow",		"0", FCVAR_REPLICATED );
+ConVar sk_plr_dmg_egon_wide			( "sk_plr_dmg_egon_wide",		"0", FCVAR_REPLICATED );
+ConVar sk_max_uranium				( "sk_max_uranium",				"0", FCVAR_REPLICATED );
+
+ConVar sk_plr_dmg_gauss				( "sk_plr_dmg_gauss",			"0", FCVAR_REPLICATED );
+
+ConVar sk_plr_dmg_grenade			( "sk_plr_dmg_grenade",			"0", FCVAR_REPLICATED );
+ConVar sk_max_grenade				( "sk_max_grenade",				"0", FCVAR_REPLICATED );
+
+ConVar sk_plr_dmg_hornet			( "sk_plr_dmg_hornet",			"0", FCVAR_REPLICATED );
+ConVar sk_npc_dmg_hornet			( "sk_npc_dmg_hornet",			"0", FCVAR_REPLICATED );
+ConVar sk_max_hornet				( "sk_max_hornet",				"0", FCVAR_REPLICATED );
+
+ConVar sk_max_snark					( "sk_max_snark",				"0", FCVAR_REPLICATED );
+
+ConVar sk_plr_dmg_tripmine			( "sk_plr_dmg_tripmine",		"0", FCVAR_REPLICATED );
+ConVar sk_max_tripmine				( "sk_max_tripmine",			"0", FCVAR_REPLICATED );
+
+ConVar sk_plr_dmg_satchel			( "sk_plr_dmg_satchel",			"0", FCVAR_REPLICATED );
+ConVar sk_max_satchel				( "sk_max_satchel",				"0", FCVAR_REPLICATED );
+
+ConVar sk_npc_dmg_12mm_bullet		( "sk_npc_dmg_12mm_bullet",		"0", FCVAR_REPLICATED );
+
+ConVar sk_mp_dmg_multiplier ( "sk_mp_dmg_multiplier", "2.0" );
+
+// Damage Queries.
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int	CHalfLife1::Damage_GetShowOnHud( void )
+{
+	int iDamage = (DMG_POISON | DMG_ACID | DMG_DISSOLVE/*DMG_FREEZE | DMG_SLOWFREEZE*/ | DMG_DROWN | DMG_BURN | DMG_SLOWBURN | DMG_NERVEGAS | DMG_RADIATION | DMG_SHOCK);
+	return iDamage;
+}
+
+#ifndef CLIENT_DLL
+
+	extern bool		g_fGameOver;
+
+	const char *CHalfLife1::GetGameDescription( void )
+	{
+		if ( IsMultiplayer() )
+		{
+			return "Half-Life 1: Deathmatch";
+		}
+		else
+		{
+			return "Half-Life 1";
+		}
+	}
+
+	class CVoiceGameMgrHelper : public IVoiceGameMgrHelper
+	{
+	public:
+		virtual bool		CanPlayerHearPlayer( CBasePlayer *pListener, CBasePlayer *pTalker, bool &bProximity )
+		{
+			return true;
+		}
+	};
+	CVoiceGameMgrHelper g_VoiceGameMgrHelper;
+	IVoiceGameMgrHelper *g_pVoiceGameMgrHelper = &g_VoiceGameMgrHelper;
+
+	//-----------------------------------------------------------------------------
+	// Purpose:
+	// Input  :
+	// Output :
+	//-----------------------------------------------------------------------------
+	CHalfLife1::CHalfLife1()
+	{
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: called each time a player uses a "cmd" command
+	// Input  : *pEdict - the player who issued the command
+	//			Use engine.Cmd_Argv,  engine.Cmd_Argv, and engine.Cmd_Argc to get 
+	//			pointers the character string command.
+	//-----------------------------------------------------------------------------
+	bool CHalfLife1::ClientCommand( CBaseEntity *pEdict, const CCommand &args )
+	{
+		if( BaseClass::ClientCommand( pEdict, args ) )
+			return true;
+
+		CHL1_Player *pPlayer = (CHL1_Player *) pEdict;
+		
+		if ( pPlayer->ClientCommand( args ) )
+			return true;
+			
+		return false;
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Player has just spawned. Equip them.
+	//-----------------------------------------------------------------------------
+	void CHalfLife1::PlayerSpawn( CBasePlayer *pPlayer )
+	{
+	//	pPlayer->EquipSuit();
+	}
+
+
+	//-----------------------------------------------------------------------------
+	// Purpose: MULTIPLAYER BODY QUE HANDLING
+	//-----------------------------------------------------------------------------
+	class CCorpse : public CBaseAnimating
+	{
+		DECLARE_CLASS( CCorpse, CBaseAnimating );
+	public:
+
+		DECLARE_SERVERCLASS();
+
+		virtual int ObjectCaps( void ) { return FCAP_DONT_SAVE; }	
+
+	public:
+		CNetworkVar( int, m_nReferencePlayer );
+	};
+
+	IMPLEMENT_SERVERCLASS_ST(CCorpse, DT_Corpse)
+		SendPropInt( SENDINFO(m_nReferencePlayer), 10, SPROP_UNSIGNED )
+	END_SEND_TABLE()
+
+	LINK_ENTITY_TO_CLASS( bodyque, CCorpse );
+
+
+	CCorpse		*g_pBodyQueueHead;
+
+	void InitBodyQue(void)
+	{
+		CCorpse *pEntity = ( CCorpse * )CreateEntityByName( "bodyque" );
+		pEntity->AddEFlags( EFL_KEEP_ON_RECREATE_ENTITIES );
+		g_pBodyQueueHead = pEntity;
+		CCorpse *p = g_pBodyQueueHead;
+		
+		// Reserve 3 more slots for dead bodies
+		for ( int i = 0; i < 3; i++ )
+		{
+			CCorpse *next = ( CCorpse * )CreateEntityByName( "bodyque" );
+			next->AddEFlags( EFL_KEEP_ON_RECREATE_ENTITIES );
+			p->SetOwnerEntity( next );
+			p = next;
+		}
+		
+		p->SetOwnerEntity( g_pBodyQueueHead );
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: make a body que entry for the given ent so the ent can be respawned elsewhere
+	// GLOBALS ASSUMED SET:  g_eoBodyQueueHead
+	//-----------------------------------------------------------------------------
+	void CopyToBodyQue( CBaseAnimating *pCorpse ) 
+	{
+		if ( pCorpse->IsEffectActive( EF_NODRAW ) )
+			return;
+
+		CCorpse *pHead	= g_pBodyQueueHead;
+
+		pHead->CopyAnimationDataFrom( pCorpse );
+
+		pHead->SetMoveType( MOVETYPE_FLYGRAVITY );
+		pHead->SetAbsVelocity( pCorpse->GetAbsVelocity() );
+		pHead->ClearFlags();
+		pHead->m_nReferencePlayer	= ENTINDEX( pCorpse );
+
+		pHead->SetLocalAngles( pCorpse->GetAbsAngles() );
+		UTIL_SetOrigin(pHead, pCorpse->GetAbsOrigin());
+
+		UTIL_SetSize(pHead, pCorpse->WorldAlignMins(), pCorpse->WorldAlignMaxs());
+		g_pBodyQueueHead = (CCorpse *)pHead->GetOwnerEntity();
+	}
+
+	//------------------------------------------------------------------------------
+	// Purpose : Initialize all default class relationships
+	// Input   :
+	// Output  :
+	//------------------------------------------------------------------------------
+	void CHalfLife1::InitDefaultAIRelationships( void )
+	{
+		int i, j;
+
+		//  Allocate memory for default relationships
+		CBaseCombatCharacter::AllocateDefaultRelationships();
+
+		// --------------------------------------------------------------
+		// First initialize table so we can report missing relationships
+		// --------------------------------------------------------------
+		for (i=0;i<NUM_AI_CLASSES;i++)
+		{
+			for (j=0;j<NUM_AI_CLASSES;j++)
+			{
+				// By default all relationships are neutral of priority zero
+				CBaseCombatCharacter::SetDefaultRelationship( (Class_T)i, (Class_T)j, D_NU, 0 );
+			}
+		}
+
+
+		// ------------------------------------------------------------
+		//	> CLASS_NONE
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_NONE,				D_NU, 0 );			
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_PLAYER,			D_NU, 0 );			
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_HUMAN_PASSIVE,	D_NU, 0 );		
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_PLAYER_ALLY,		D_NU, 0 );		
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_ALIEN_PREY,		D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_ALIEN_MILITARY,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_ALIEN_MONSTER,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_ALIEN_PREDATOR,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_HUMAN_MILITARY,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_MACHINE,			D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_ALIEN_BIOWEAPON,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_PLAYER_BIOWEAPON,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_INSECT,			D_NU, 0 );
+		
+		
+		// ------------------------------------------------------------
+		//	> CLASS_HUMAN_PASSIVE
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_NONE,				D_NU, 0 );			
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_PLAYER,			D_LI, 0 );	
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_HUMAN_PASSIVE,	D_LI, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_PLAYER_ALLY,		D_LI, 0 );	
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_ALIEN_PREY,		D_FR, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_ALIEN_MILITARY,	D_FR, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_ALIEN_MONSTER,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_ALIEN_PREDATOR,	D_FR, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_HUMAN_MILITARY,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_MACHINE,			D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_ALIEN_BIOWEAPON,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_PLAYER_BIOWEAPON,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_INSECT,			D_NU, 0 );
+		
+		
+
+		// ------------------------------------------------------------
+		//	> CLASS_PLAYER
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,				CLASS_NONE,				D_NU, 0 );			
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,				CLASS_PLAYER,			D_LI, 0 );			
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,				CLASS_HUMAN_PASSIVE,	D_LI, 0 );	
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,				CLASS_PLAYER_ALLY,		D_LI, 0 );	
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,		  	    CLASS_ALIEN_PREY,		D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,		  	    CLASS_ALIEN_MILITARY,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,				CLASS_ALIEN_MONSTER,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,				CLASS_ALIEN_PREDATOR,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,				CLASS_HUMAN_MILITARY,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,				CLASS_MACHINE,			D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,				CLASS_ALIEN_BIOWEAPON,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,				CLASS_PLAYER_BIOWEAPON,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,				CLASS_INSECT,			D_NU, 0 );
+
+		// ------------------------------------------------------------
+		//	> CLASS_PLAYER_ALLY
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_NONE,				D_NU, 0 );			
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_PLAYER,			D_LI, 0 );			
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_HUMAN_PASSIVE,	D_LI, 0 );	
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_PLAYER_ALLY,		D_LI, 0 );	
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_ALIEN_PREY,		D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_ALIEN_MILITARY,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_ALIEN_MONSTER,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_ALIEN_PREDATOR,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_HUMAN_MILITARY,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_MACHINE,			D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_ALIEN_BIOWEAPON,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_PLAYER_BIOWEAPON,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_INSECT,			D_NU, 0 );
+
+		// ------------------------------------------------------------
+		//	> CLASS_ALIEN_PREY
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_NONE,				D_NU, 0 );			
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_PLAYER,			D_HT, 0 );			
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_PLAYER_ALLY,		D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_HUMAN_PASSIVE,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_ALIEN_PREY,		D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_ALIEN_MILITARY,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_ALIEN_MONSTER,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_ALIEN_PREDATOR,	D_FR, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_HUMAN_MILITARY,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_MACHINE,			D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_ALIEN_BIOWEAPON,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_PLAYER_BIOWEAPON,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_INSECT,			D_NU, 0 );
+
+		// ------------------------------------------------------------
+		//	> CLASS_ALIEN_MILITARY
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_NONE,				D_NU, 0 );			
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_PLAYER,			D_HT, 0 );			
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_PLAYER_ALLY,		D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_HUMAN_PASSIVE,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_ALIEN_PREY,		D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_ALIEN_MILITARY,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_ALIEN_MONSTER,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_ALIEN_PREDATOR,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_HUMAN_MILITARY,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_MACHINE,			D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_ALIEN_BIOWEAPON,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_PLAYER_BIOWEAPON,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_INSECT,			D_NU, 0 );
+
+		// ------------------------------------------------------------
+		//	> CLASS_ALIEN_MONSTER
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_NONE,				D_NU, 0 );			
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_PLAYER,			D_HT, 0 );			
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_PLAYER_ALLY,		D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_HUMAN_PASSIVE,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_ALIEN_PREY,		D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_ALIEN_MILITARY,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_ALIEN_MONSTER,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_ALIEN_PREDATOR,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_HUMAN_MILITARY,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_MACHINE,			D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_ALIEN_BIOWEAPON,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_PLAYER_BIOWEAPON,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_INSECT,			D_NU, 0 );
+
+		// ------------------------------------------------------------
+		//	> CLASS_ALIEN_PREDATOR
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_NONE,				D_NU, 0 );			
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_PLAYER,			D_HT, 0 );			
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_PLAYER_ALLY,		D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_HUMAN_PASSIVE,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_ALIEN_PREY,		D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_ALIEN_MILITARY,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_ALIEN_MONSTER,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_ALIEN_PREDATOR,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_HUMAN_MILITARY,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_MACHINE,			D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_ALIEN_BIOWEAPON,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_PLAYER_BIOWEAPON,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_INSECT,			D_NU, 0 );
+
+		// ------------------------------------------------------------
+		//	> CLASS_HUMAN_MILITARY
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_NONE,				D_NU, 0 );			
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_PLAYER,			D_HT, 0 );			
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_PLAYER_ALLY,		D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_HUMAN_PASSIVE,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_ALIEN_PREY,		D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_ALIEN_MILITARY,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_ALIEN_MONSTER,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_ALIEN_PREDATOR,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_HUMAN_MILITARY,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_MACHINE,			D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_ALIEN_BIOWEAPON,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_PLAYER_BIOWEAPON,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_INSECT,			D_NU, 0 );
+
+		// ------------------------------------------------------------
+		//	> CLASS_MACHINE
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_NONE,				D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_MACHINE,			D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_PLAYER,			D_HT, 0 );			
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_HUMAN_PASSIVE,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_HUMAN_MILITARY,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_ALIEN_MILITARY,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_ALIEN_MONSTER,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_ALIEN_PREY,		D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_ALIEN_PREDATOR,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_PLAYER_ALLY,		D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_ALIEN_BIOWEAPON,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_PLAYER_BIOWEAPON,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_INSECT,			D_NU, 0 );
+
+		// ------------------------------------------------------------
+		//	> CLASS_ALIEN_BIOWEAPON
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_NONE,				D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_MACHINE,			D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_PLAYER,			D_HT, 0 );			
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_HUMAN_PASSIVE,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_HUMAN_MILITARY,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_ALIEN_MILITARY,	D_LI, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_ALIEN_MONSTER,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_ALIEN_PREY,		D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_ALIEN_PREDATOR,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_PLAYER_ALLY,		D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_ALIEN_BIOWEAPON,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_PLAYER_BIOWEAPON,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_INSECT,			D_NU, 0 );
+
+		// ------------------------------------------------------------
+		//	> CLASS_PLAYER_BIOWEAPON
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_NONE,				D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_MACHINE,			D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_PLAYER,			D_HT, 0 );			
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_HUMAN_PASSIVE,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_HUMAN_MILITARY,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_ALIEN_MILITARY,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_ALIEN_MONSTER,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_ALIEN_PREY,		D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_ALIEN_PREDATOR,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_PLAYER_ALLY,		D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_ALIEN_BIOWEAPON,	D_HT, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_PLAYER_BIOWEAPON,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_INSECT,			D_NU, 0 );
+		
+		
+		// ------------------------------------------------------------
+		//	> CLASS_INSECT
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_NONE,				D_FR, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_MACHINE,			D_FR, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_PLAYER,			D_FR, 0 );			
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_HUMAN_PASSIVE,	D_FR, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_HUMAN_MILITARY,	D_FR, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_ALIEN_MILITARY,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_ALIEN_MONSTER,	D_FR, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_ALIEN_PREY,		D_FR, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_ALIEN_PREDATOR,	D_FR, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_PLAYER_ALLY,		D_FR, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_ALIEN_BIOWEAPON,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_PLAYER_BIOWEAPON,	D_NU, 0 );
+		CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_INSECT,			D_NU, 0 );
+	}
+
+	//------------------------------------------------------------------------------
+	// Purpose : Return classify text for classify type
+	// Input   :
+	// Output  :
+	//------------------------------------------------------------------------------
+	const char* CHalfLife1::AIClassText(int classType)
+	{
+		switch (classType)
+		{
+			case CLASS_NONE:			return "CLASS_NONE";
+			case CLASS_HUMAN_PASSIVE:	return "CLASS_HUMAN_PASSIVE";
+			case CLASS_PLAYER_ALLY:		return "CLASS_PLAYER_ALLY";
+			case CLASS_PLAYER:			return "CLASS_PLAYER";
+			case CLASS_ALIEN_PREY:		return "CLASS_ALIEN_PREY";
+			case CLASS_ALIEN_MILITARY:	return "CLASS_ALIEN_MILITARY"; 
+			case CLASS_ALIEN_MONSTER:	return "CLASS_ALIEN_MONSTER";
+			case CLASS_ALIEN_PREDATOR:	return "CLASS_ALIEN_PREDATOR";
+			case CLASS_HUMAN_MILITARY:	return "CLASS_HUMAN_MILITARY";
+			case CLASS_MACHINE:			return "CLASS_MACHINE";
+			case CLASS_ALIEN_BIOWEAPON:	return "CLASS_ALIEN_BIOWEAPON";
+			case CLASS_PLAYER_BIOWEAPON: return "CLASS_PLAYER_BIOWEAPON";
+		
+			default:					return "MISSING CLASS in ClassifyText()";
+		}
+	}
+
+
+	void CHalfLife1::PlayerThink( CBasePlayer *pPlayer )
+	{
+	}
+
+
+	bool CHalfLife1::CanHavePlayerItem( CBasePlayer *pPlayer, CBaseCombatWeapon *pWeapon )
+	{
+		if ( FClassnameIs( pWeapon, "weapon_satchel" ) )
+		{
+			CWeaponSatchel *satchel = static_cast< CWeaponSatchel * >( pPlayer->Weapon_OwnsThisType( "weapon_satchel" ) );
+			if ( satchel )
+			{
+				if ( satchel->HasChargeDeployed() )
+				{
+					return false;
+				}
+			}
+		}
+
+		return true;
+	}
+
+		
+	float CHalfLife1::FlPlayerFallDamage( CBasePlayer *pPlayer )
+	{
+		CBaseEntity *pGroundEntity = pPlayer->GetGroundEntity();
+
+		if( pGroundEntity && pGroundEntity->ClassMatches( "func_breakable" ) )
+		{		
+			// FIXME touchtrace will be wrong.
+			pGroundEntity->Touch( pPlayer );
+
+			if( pGroundEntity->m_iHealth <= 0 )
+			{
+				// The breakable broke when we hit it, don't take falling damage
+				return 0;
+			}
+		}
+
+		return BaseClass::FlPlayerFallDamage( pPlayer );
+	}
+
+
+	class CTraceFilterHitAllExcept : public CTraceFilter
+	{
+	public:
+		// It does have a base, but we'll never network anything below here..
+		DECLARE_CLASS_NOBASE( CTraceFilterHitAllExcept );
+
+		CTraceFilterHitAllExcept( const IHandleEntity *passedict )
+		{
+			m_pPassEnt = passedict;
+		}
+
+		bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask )
+		{ 
+			if ( m_pPassEnt && ( m_pPassEnt == pServerEntity ) )
+			{
+				return false;
+			}
+		
+			return true;
+		}
+
+	private:
+		const IHandleEntity *m_pPassEnt;
+	};
+
+	void CHalfLife1::RadiusDamage( const CTakeDamageInfo &info, const Vector &vecSrcIn, float flRadius, int iClassIgnore )
+	{
+		CBaseEntity *pEntity = NULL;
+		trace_t		tr;
+		float		flAdjustedDamage, falloff;
+		Vector		vecSpot;
+
+		Vector vecSrc = vecSrcIn;
+
+		if ( flRadius )
+			falloff = info.GetDamage() / flRadius;
+		else
+			falloff = 1.0;
+
+		int bInWater = (UTIL_PointContents ( vecSrc ) & MASK_WATER) ? true : false;
+		
+		vecSrc.z += 1;// in case grenade is lying on the ground
+
+		// iterate on all entities in the vicinity.
+		for ( CEntitySphereQuery sphere( vecSrc, flRadius ); ( pEntity = sphere.GetCurrentEntity() ) != NULL; sphere.NextEntity() )
+		{
+			if ( pEntity->m_takedamage != DAMAGE_NO )
+			{
+				// UNDONE: this should check a damage mask, not an ignore
+				if ( iClassIgnore != CLASS_NONE && pEntity->Classify() == iClassIgnore )
+				{// houndeyes don't hurt other houndeyes with their attack
+					continue;
+				}
+
+				// blast's don't tavel into or out of water
+				if (bInWater && pEntity->GetWaterLevel() == 0)
+					continue;
+				if (!bInWater && pEntity->GetWaterLevel() == 3)
+					continue;
+
+				// radius damage can only be blocked by the world
+				vecSpot = pEntity->BodyTarget( vecSrc );
+
+				CTraceFilterHitAllExcept traceFilter( info.GetInflictor() );
+  				UTIL_TraceLine( vecSrc, vecSpot, CONTENTS_SOLID, &traceFilter, &tr );
+				
+				if ( tr.fraction == 1.0 || tr.m_pEnt == pEntity )
+				{// the explosion can 'see' this entity, so hurt them!
+					if (tr.startsolid)
+					{
+						// if we're stuck inside them, fixup the position and distance
+						tr.endpos = vecSrc;
+						tr.fraction = 0.0;
+					}
+					
+					// decrease damage for an ent that's farther from the bomb.
+					flAdjustedDamage = ( vecSrc - tr.endpos ).Length() * falloff;
+					flAdjustedDamage = info.GetDamage() - flAdjustedDamage;
+				
+					if ( flAdjustedDamage > 0 )
+					{
+						CTakeDamageInfo adjustedInfo = info;
+						adjustedInfo.SetDamage( flAdjustedDamage );
+
+	 					Vector vecDir = vecSpot - vecSrc;
+	 					VectorNormalize( vecDir );
+
+						// If we don't have a damage force, manufacture one
+						if ( adjustedInfo.GetDamagePosition() == vec3_origin || adjustedInfo.GetDamageForce() == vec3_origin )
+						{
+							CalculateExplosiveDamageForce( &adjustedInfo, vecDir, vecSrc );
+						}
+						else
+						{
+							// Assume the force passed in is the maximum force. Decay it based on falloff.
+							float flForce = adjustedInfo.GetDamageForce().Length() * falloff;
+							adjustedInfo.SetDamageForce( vecDir * flForce );
+							adjustedInfo.SetDamagePosition( vecSrc );
+						}
+
+						if (tr.fraction != 1.0)
+						{
+							ClearMultiDamage( );
+							Vector dir = tr.endpos - vecSrc;
+							VectorNormalize( dir );
+							pEntity->DispatchTraceAttack( adjustedInfo, dir, &tr );
+							ApplyMultiDamage();
+						}
+						else
+						{
+							pEntity->TakeDamage( adjustedInfo );
+						}
+						// Now hit all triggers along the way that respond to damage... 
+						Vector dir = tr.endpos - vecSrc;
+						pEntity->TraceAttackToTriggers( adjustedInfo, vecSrc, tr.endpos, dir );
+					}
+				}
+			}
+		}
+	}
+#endif
+
+
+
+// ------------------------------------------------------------------------------------- //
+// CHalfLife1 shared implementation.
+// ------------------------------------------------------------------------------------- //
+
+bool CHalfLife1::ShouldCollide( int collisionGroup0, int collisionGroup1 )
+{
+	// HL2 treats movement and tracing against players the same, so just remap here
+	if ( collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT )
+	{
+		collisionGroup0 = COLLISION_GROUP_PLAYER;
+	}
+
+	if( collisionGroup1 == COLLISION_GROUP_PLAYER_MOVEMENT )
+	{
+		collisionGroup1 = COLLISION_GROUP_PLAYER;
+	}
+
+	if ( collisionGroup0 > collisionGroup1 )
+	{
+		// swap so that lowest is always first
+		int tmp = collisionGroup0;
+		collisionGroup0 = collisionGroup1;
+		collisionGroup1 = tmp;
+	}
+
+	return BaseClass::ShouldCollide( collisionGroup0, collisionGroup1 ); 
+}
+
+// ------------------------------------------------------------------------------------- //
+// Global functions.
+// ------------------------------------------------------------------------------------- //
+
+// shared ammo definition
+// JAY: Trying to make a more physical bullet response
+#define BULLET_MASS_GRAINS_TO_LB(grains)	(0.002285*(grains)/16.0f)
+#define BULLET_MASS_GRAINS_TO_KG(grains)	lbs2kg(BULLET_MASS_GRAINS_TO_LB(grains))
+
+// exaggerate all of the forces, but use real numbers to keep them consistent
+#define BULLET_IMPULSE_EXAGGERATION			3
+
+// convert a velocity in ft/sec and a mass in grains to an impulse in kg in/s
+#define BULLET_IMPULSE(grains, ftpersec)	((ftpersec)*12*BULLET_MASS_GRAINS_TO_KG(grains)*BULLET_IMPULSE_EXAGGERATION)
+
+CAmmoDef *GetAmmoDef()
+{
+	static CAmmoDef def;
+	static bool bInitted = false;
+
+	if ( !bInitted )
+	{
+		bInitted = true;
+		
+		def.AddAmmoType( "9mmRound",		DMG_BULLET | DMG_NEVERGIB,	TRACER_LINE, "sk_plr_dmg_9mm_bullet",	"sk_npc_dmg_9mm_bullet","sk_max_9mm_bullet",	BULLET_IMPULSE(500, 1325), 0 );
+		def.AddAmmoType( "357Round",		DMG_BULLET | DMG_NEVERGIB,	TRACER_NONE, "sk_plr_dmg_357_bullet",	NULL,					"sk_max_357_bullet",	BULLET_IMPULSE(650, 6000), 0 );
+		def.AddAmmoType( "Buckshot",		DMG_BULLET | DMG_BUCKSHOT,	TRACER_LINE, "sk_plr_dmg_buckshot",		NULL,					"sk_max_buckshot",		BULLET_IMPULSE(200, 1200), 0 );
+		def.AddAmmoType( "XBowBolt",		DMG_BULLET | DMG_NEVERGIB,	TRACER_LINE, "sk_plr_dmg_xbow_bolt_plr",NULL,					"sk_max_xbow_bolt",		BULLET_IMPULSE( 200, 1200), 0 );
+		def.AddAmmoType( "MP5_Grenade",		DMG_BURN | DMG_BLAST,		TRACER_NONE, "sk_plr_dmg_mp5_grenade",	NULL,					"sk_max_mp5_grenade",	0, 0 );
+		def.AddAmmoType( "RPG_Rocket",		DMG_BURN | DMG_BLAST,		TRACER_NONE, "sk_plr_dmg_rpg",			NULL,					"sk_max_rpg_rocket",	0, 0 );
+		def.AddAmmoType( "Uranium",			DMG_ENERGYBEAM,				TRACER_NONE, NULL,						NULL,					"sk_max_uranium",		0, 0 );
+		def.AddAmmoType( "Grenade",			DMG_BURN | DMG_BLAST,		TRACER_NONE, "sk_plr_dmg_grenade",		NULL,					"sk_max_grenade",		0, 0 );
+		def.AddAmmoType( "Hornet",			DMG_BULLET,					TRACER_NONE, "sk_plr_dmg_hornet",		"sk_npc_dmg_hornet",	"sk_max_hornet",		BULLET_IMPULSE(100, 1200), 0 );
+		def.AddAmmoType( "Snark",			DMG_SLASH,					TRACER_NONE, "sk_snark_dmg_bite",		NULL,					"sk_max_snark",			0, 0 );
+		def.AddAmmoType( "TripMine",		DMG_BURN | DMG_BLAST,		TRACER_NONE, "sk_plr_dmg_tripmine",		NULL,					"sk_max_tripmine",		0, 0 );
+		def.AddAmmoType( "Satchel",			DMG_BURN | DMG_BLAST,		TRACER_NONE, "sk_plr_dmg_satchel",		NULL,					"sk_max_satchel",		0, 0 );
+
+		def.AddAmmoType( "12mmRound",		DMG_BULLET | DMG_NEVERGIB,	TRACER_LINE, NULL,						"sk_npc_dmg_12mm_bullet",NULL,					BULLET_IMPULSE(300, 1200), 0 );
+
+		def.AddAmmoType( "Gravity",			DMG_CRUSH,					TRACER_NONE, 0,							0,						8,					0, 0 );
+	}
+
+	return &def;
+}

game/shared/hl1/hl1_gamerules.h

@@ -0,0 +1,65 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: The HL2 Game rules object
+//
+// $Workfile:     $
+// $Date:         $
+//
+//-----------------------------------------------------------------------------
+// $Log: $
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef HL1_GAMERULES_H
+#define HL1_GAMERULES_H
+#pragma once
+
+#include "gamerules.h"
+#include "singleplay_gamerules.h"
+
+
+#ifdef CLIENT_DLL
+	#define CHalfLife1 C_HalfLife1
+#endif
+
+
+class CHalfLife1 : public CSingleplayRules
+{
+public:
+
+	DECLARE_CLASS( CHalfLife1, CSingleplayRules );
+
+	// Damage Queries.
+	virtual int		Damage_GetShowOnHud( void );
+
+	// Client/server shared implementation.
+	virtual bool ShouldCollide( int collisionGroup0, int collisionGroup1 );
+
+
+#ifndef CLIENT_DLL
+	
+	CHalfLife1();
+	virtual ~CHalfLife1() {}
+
+	virtual bool			ClientCommand( CBaseEntity *pEdict, const CCommand &args );
+	virtual void			PlayerSpawn( CBasePlayer *pPlayer );
+
+	virtual void			InitDefaultAIRelationships( void );
+	virtual const char *	AIClassText(int classType);
+	virtual const char *	GetGameDescription( void );
+	virtual float			FlPlayerFallDamage( CBasePlayer *pPlayer );
+
+	// Ammo
+	virtual void			PlayerThink( CBasePlayer *pPlayer );
+	bool					CanHavePlayerItem( CBasePlayer *pPlayer, CBaseCombatWeapon *pWeapon );
+
+	void					RadiusDamage( const CTakeDamageInfo &info, const Vector &vecSrc, float flRadius, int iClassIgnore );
+
+	int						DefaultFOV( void ) { return 90; }
+
+#endif
+
+};
+
+#endif // HL1_GAMERULES_H

game/shared/hl1/hl1_player_shared.cpp

@@ -0,0 +1,373 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+#include "cbase.h"
+#include "tier0/vprof.h"
+
+#ifdef CLIENT_DLL
+#include "hl1_player_shared.h"
+#include "hl1/c_hl1mp_player.h"
+//#define CRecipientFilter C_RecipientFilter
+#else
+#include "hl1mp_player.h"
+#endif
+
+// When moving this fast, he plays run anim.
+#define ARBITRARY_RUN_SPEED		175.0f
+
+#define MAX_STANDING_RUN_SPEED	320
+#define MAX_CROUCHED_RUN_SPEED	110
+
+
+// ------------------------------------------------------------------------------------------------ //
+// CPlayerAnimState declaration.
+// ------------------------------------------------------------------------------------------------ //
+
+class CPlayerAnimState : public IHL1MPPlayerAnimState, public CBasePlayerAnimState
+{
+public:
+	
+	DECLARE_CLASS( CPlayerAnimState, CBasePlayerAnimState );
+
+	CPlayerAnimState();
+	void Init( CHL1MP_Player *pPlayer );
+
+	// 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 );
+	virtual int CalcAimLayerSequence( float *flCycle, float *flAimSequenceWeight, bool bForceIdle );
+	virtual float SetOuterBodyYaw( float flValue );
+	virtual Activity CalcMainActivity();
+	virtual float GetCurrentMaxGroundSpeed();
+	virtual void ClearAnimationState();
+	virtual bool ShouldUpdateAnimState();
+	virtual int SelectWeightedSequence( Activity activity ) ;
+
+	float CalcMovementPlaybackRate( bool *bIsMoving );
+
+	virtual void		ComputePoseParam_BodyPitch( CStudioHdr *pStudioHdr );
+
+
+private:
+	
+	const char* GetWeaponSuffix();
+	bool HandleJumping();
+	bool HandleDeath( Activity *deathActivity );
+
+
+private:
+	
+	CHL1MP_Player *m_pOuter;
+	
+	bool m_bJumping;
+	bool m_bFirstJumpFrame;
+	float m_flJumpStartTime;
+
+	bool m_bFiring;
+	float m_flFireStartTime;
+
+	bool m_bDying;
+	Activity m_DeathActivity;
+};
+
+
+IHL1MPPlayerAnimState* CreatePlayerAnimState( CHL1MP_Player *pPlayer )
+{
+	CPlayerAnimState *pRet = new CPlayerAnimState;
+	pRet->Init( pPlayer );
+	return pRet;
+}
+
+
+// ----------------------------------------------------------------------------- //
+// CPlayerAnimState implementation.
+// ----------------------------------------------------------------------------- //
+
+CPlayerAnimState::CPlayerAnimState()
+{
+	m_pOuter = NULL;
+	m_bJumping = false;
+	m_bFirstJumpFrame = false;
+	m_bFiring = false;
+}
+
+
+void CPlayerAnimState::Init( CHL1MP_Player *pPlayer )
+{
+	m_pOuter = pPlayer;
+	
+	CModAnimConfig config;
+	config.m_flMaxBodyYawDegrees = 90;
+	config.m_LegAnimType = LEGANIM_GOLDSRC;
+	config.m_bUseAimSequences = true;
+
+	BaseClass::Init( pPlayer, config );
+}
+
+
+const char* CPlayerAnimState::GetWeaponSuffix()
+{
+	CBaseCombatWeapon *pWeapon = m_pOuter->GetActiveWeapon();
+	if ( pWeapon )
+		return pWeapon->GetWpnData().szAnimationPrefix;
+	else
+		return "shotgun";
+}
+
+
+int CPlayerAnimState::CalcAimLayerSequence( float *flCycle, float *flAimSequenceWeight, bool bForceIdle )
+{
+	const char *pWeaponSuffix = GetWeaponSuffix();
+	if ( !pWeaponSuffix )
+		return 0;
+
+	if ( strcmp( pWeaponSuffix, "glock" ) == 0 )
+		pWeaponSuffix = "onehanded";
+
+	// Are we aiming or firing?
+	const char *pAimOrShoot = "aim";
+	if ( m_bFiring )
+		pAimOrShoot = "shoot";
+
+	// Are we standing or crouching?
+	int iSequence = 0;
+	const char *pPrefix = "ref";
+	if ( m_bDying )
+	{
+		// While dying, only play the main sequence.. don't layer this one on top.
+		*flAimSequenceWeight = 0;	
+	}
+	else
+	{
+		switch ( GetCurrentMainSequenceActivity() )
+		{
+			case ACT_CROUCHIDLE:
+			case ACT_RUN_CROUCH:
+				pPrefix = "crouch";
+				break;
+		}
+	}
+
+	iSequence = CalcSequenceIndex( "%s_%s_%s", pPrefix, pAimOrShoot, pWeaponSuffix );
+	
+	// Check if we're done firing.
+	if ( m_bFiring )
+	{
+		float dur = m_pOuter->SequenceDuration( iSequence );
+		*flCycle = (gpGlobals->curtime - m_flFireStartTime) / dur;
+		if ( *flCycle >= 1 )
+		{
+			*flCycle = 1;
+			m_bFiring = false;
+		}
+	}	
+
+	return iSequence;
+}
+
+
+void CPlayerAnimState::DoAnimationEvent( PlayerAnimEvent_t event, int nData )
+{
+	if ( event == PLAYERANIMEVENT_JUMP )
+	{
+		// Main animation goes to ACT_HOP.
+		m_bJumping = true;
+		m_bFirstJumpFrame = true;
+		m_flJumpStartTime = gpGlobals->curtime;
+	}
+	else if ( event == PLAYERANIMEVENT_FIRE_GUN )
+	{
+		// The middle part of the aim layer sequence becomes "shoot" until that animation is complete.
+		m_bFiring = true;
+		m_flFireStartTime = gpGlobals->curtime;
+	}
+}
+
+
+float CPlayerAnimState::SetOuterBodyYaw( float flValue )
+{
+//	m_pOuter->SetBoneController( 0, flValue );
+
+	float fAcc = flValue / 4;
+
+	for ( int i = 0; i < 4; i++ )
+	{
+		m_pOuter->SetBoneController( i, fAcc );
+	}
+
+	return flValue;
+}
+
+
+bool CPlayerAnimState::HandleJumping()
+{
+	if ( m_bJumping )
+	{
+		if ( m_bFirstJumpFrame )
+		{
+			m_bFirstJumpFrame = false;
+			RestartMainSequence();	// Reset the animation.
+		}
+
+		// Don't check if he's on the ground for a sec.. sometimes the client still has the
+		// on-ground flag set right when the message comes in.
+		if ( gpGlobals->curtime - m_flJumpStartTime > 0.2f )
+		{
+			if ( m_pOuter->GetFlags() & FL_ONGROUND )
+			{
+				m_bJumping = false;
+				RestartMainSequence();	// Reset the animation.
+			}
+		}
+	}
+
+	// Are we still jumping? If so, keep playing the jump animation.
+	return m_bJumping;
+}
+
+int CPlayerAnimState::SelectWeightedSequence( Activity activity ) 
+{
+	return m_pOuter->m_iRealSequence;
+}
+
+bool CPlayerAnimState::HandleDeath( Activity *deathActivity )
+{
+	if ( m_bDying )
+	{
+		if ( m_pOuter->IsAlive() )
+		{
+			m_bDying = false;
+		}
+		else
+		{
+			*deathActivity = m_DeathActivity;
+		}
+	}
+	return m_bDying;
+}
+
+
+Activity CPlayerAnimState::CalcMainActivity()
+{
+	Activity deathActivity = ACT_IDLE;
+	if ( HandleDeath( &deathActivity ) )
+	{
+		return deathActivity;
+	}
+	else if ( HandleJumping() )
+	{
+		return ACT_HOP;
+	}
+	else
+	{
+		Activity idealActivity = ACT_IDLE;
+		float flOuterSpeed = GetOuterXYSpeed();
+
+		if ( m_pOuter->GetFlags() & FL_DUCKING )
+		{
+			if ( flOuterSpeed > 0.1f )
+				idealActivity = ACT_RUN_CROUCH;
+			else
+				idealActivity = ACT_CROUCHIDLE;
+		}
+		else
+		{
+			if ( flOuterSpeed > 0.1f )
+			{
+				if ( flOuterSpeed > ARBITRARY_RUN_SPEED )
+					idealActivity = ACT_RUN;
+				else
+					idealActivity = ACT_WALK;
+			}
+			else
+			{
+				idealActivity = ACT_IDLE;
+			}
+		}
+
+		return idealActivity	;
+	}
+}
+
+
+float CPlayerAnimState::GetCurrentMaxGroundSpeed()
+{
+	Activity act = GetCurrentMainSequenceActivity();
+	if ( act == ACT_CROUCHIDLE || act == ACT_RUN_CROUCH )
+		return MAX_CROUCHED_RUN_SPEED;
+	else
+		return MAX_STANDING_RUN_SPEED;
+}
+
+
+void CPlayerAnimState::ClearAnimationState()
+{
+	m_bJumping = false;
+	m_bFiring = false;
+	m_bDying = false;
+
+	BaseClass::ClearAnimationState();
+}
+
+
+bool CPlayerAnimState::ShouldUpdateAnimState()
+{
+	return true;
+}
+
+float CPlayerAnimState::CalcMovementPlaybackRate( bool *bIsMoving )
+{
+	// Determine ideal playback rate
+	Vector vel;
+	GetOuterAbsVelocity( vel );
+
+	float flReturnValue = BaseClass::CalcMovementPlaybackRate( bIsMoving );
+
+	Activity eActivity = GetOuter()->GetSequenceActivity( GetOuter()->GetSequence() ) ;
+
+	if ( eActivity == ACT_RUN || eActivity == ACT_WALK || eActivity == ACT_CROUCH )
+	{
+		VectorNormalize( vel );
+
+		Vector vForward;
+		AngleVectors( GetOuter()->EyeAngles(), &vForward );
+
+		float flDot = DotProduct( vel, vForward );
+
+		if ( flDot < 0 )
+		{
+			flReturnValue *= -1;
+		}
+	}
+
+	return flReturnValue;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPlayerAnimState::ComputePoseParam_BodyPitch( CStudioHdr *pStudioHdr )
+{
+	VPROF( "CBasePlayerAnimState::ComputePoseParam_BodyPitch" );
+
+	// Get pitch from v_angle
+	float flPitch = -m_flEyePitch;
+	if ( flPitch > 180.0f )
+	{
+		flPitch -= 360.0f;
+	}
+	flPitch = clamp( flPitch, -50, 45 );
+
+	// See if we have a blender for pitch
+	int pitch = GetOuter()->LookupPoseParameter( pStudioHdr, "XR" );
+	if ( pitch < 0 )
+		return;
+
+	GetOuter()->SetPoseParameter( pStudioHdr, pitch, flPitch );
+	g_flLastBodyPitch = flPitch;
+}
+

game/shared/hl1/hl1_player_shared.h

@@ -0,0 +1,53 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef HL1_PLAYER_SHARED_H
+#define HL1_PLAYER_SHARED_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "cbase.h"
+#include "base_playeranimstate.h"
+
+// Shared header file for players
+#if defined( CLIENT_DLL )
+//#define CHL1_Player C_BaseHLPlayer	//FIXME: Lovely naming job between server and client here...
+class C_HL1MP_Player;
+#define CHL1MP_Player C_HL1MP_Player
+#else
+//#include "hl1_player.h"
+class CHL1MP_Player;
+#endif
+
+#include "studio.h"
+
+enum PlayerAnimEvent_t
+{
+	PLAYERANIMEVENT_FIRE_GUN=0,
+	PLAYERANIMEVENT_THROW_GRENADE,
+	PLAYERANIMEVENT_JUMP,
+	PLAYERANIMEVENT_RELOAD,
+	PLAYERANIMEVENT_DIE,
+	
+	PLAYERANIMEVENT_COUNT
+};
+
+class IHL1MPPlayerAnimState : 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;
+};
+
+IHL1MPPlayerAnimState* CreatePlayerAnimState( CHL1MP_Player *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 // HL1_PLAYER_SHARED_H

game/shared/hl1/hl1_shareddefs.h

@@ -0,0 +1,20 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef HL1_SHAREDDEFS_H
+#define HL1_SHAREDDEFS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+//--------------
+// HL1 SPECIFIC
+//--------------
+#define DMG_MISSILEDEFENSE	(DMG_LASTGENERICFLAG<<2)	// The only kind of damage missiles take. (special missile defense)
+
+
+#endif // HL1_SHAREDDEFS_H

game/shared/hl1/hl1_usermessages.cpp

@@ -0,0 +1,42 @@
+//========= 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( void )
+{
+	usermessages->Register( "Geiger", 1 );
+	usermessages->Register( "Train", 1 );
+	usermessages->Register( "HudText", -1 );
+	usermessages->Register( "SayText", -1 );
+	usermessages->Register( "SayText2", -1 );
+	usermessages->Register( "TextMsg", -1 );
+	usermessages->Register( "HudMsg", -1 );
+	usermessages->Register( "ResetHUD", 1 );		// called every respawn
+	usermessages->Register( "GameTitle", 0 );
+	usermessages->Register( "ItemPickup", -1 );
+	usermessages->Register( "ShowMenu", -1 );
+	usermessages->Register( "Shake", 13 );
+	usermessages->Register( "Fade", 10 );
+	usermessages->Register( "VGUIMenu", -1 );	// Show VGUI menu
+	usermessages->Register( "Rumble", 3 );	// Send a rumble to a controller
+	usermessages->Register( "Battery", 2 );
+	usermessages->Register( "Damage", 18 );
+	usermessages->Register( "VoiceMask", VOICE_MAX_PLAYERS_DW*4 * 2 + 1 );
+	usermessages->Register( "RequestState", 0 );
+	usermessages->Register( "CloseCaption", -1 ); // Show a caption (by string id number)(duration in 10th of a second)
+	usermessages->Register( "HintText", -1 );	// Displays hint text display
+	usermessages->Register( "KeyHintText", -1 );	// Displays hint text display
+	usermessages->Register( "AmmoDenied", 2 );
+
+	// NVNT register haptic user messages
+	RegisterHapticMessages();
+}

game/shared/hl1/hl1mp_basecombatweapon_shared.cpp

@@ -0,0 +1,135 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hl1mp_basecombatweapon_shared.h"
+
+#include "effect_dispatch_data.h"
+
+#ifdef CLIENT_DLL
+	#include "c_te_effect_dispatch.h"
+#else
+	#include "te_effect_dispatch.h"
+#endif
+
+#include "hl1_player_shared.h"
+
+LINK_ENTITY_TO_CLASS( basehl1mpcombatweapon, CBaseHL1MPCombatWeapon );
+
+IMPLEMENT_NETWORKCLASS_ALIASED( BaseHL1MPCombatWeapon , DT_BaseHL1MPCombatWeapon )
+
+BEGIN_NETWORK_TABLE( CBaseHL1MPCombatWeapon , DT_BaseHL1MPCombatWeapon )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CBaseHL1MPCombatWeapon )
+END_PREDICTION_DATA()
+
+
+CBaseHL1MPCombatWeapon::CBaseHL1MPCombatWeapon()
+{
+	SetPredictionEligible( true );
+	AddSolidFlags( FSOLID_TRIGGER ); // Nothing collides with these but it gets touches.
+}
+
+
+void CBaseHL1MPCombatWeapon::EjectShell( CBaseEntity *pPlayer, int iType )
+{
+	QAngle angShellAngles = pPlayer->GetAbsAngles();
+
+	Vector vecForward, vecRight, vecUp;
+	AngleVectors( angShellAngles, &vecForward, &vecRight, &vecUp );
+
+	Vector vecShellPosition = pPlayer->GetAbsOrigin() + pPlayer->GetViewOffset();
+	switch ( iType )
+	{
+	case 0:
+	default:
+		vecShellPosition += vecRight * 4;
+		vecShellPosition += vecUp * -12;
+		vecShellPosition += vecForward * 20;
+		break;
+	case 1:
+		vecShellPosition += vecRight * 6;
+		vecShellPosition += vecUp * -12;
+		vecShellPosition += vecForward * 32;
+		break;
+	}
+
+	Vector vecShellVelocity	= vec3_origin; // pPlayer->GetAbsVelocity();
+	vecShellVelocity += vecRight * random->RandomFloat( 50, 70 );
+	vecShellVelocity += vecUp * random->RandomFloat( 100, 150 );
+	vecShellVelocity += vecForward * 25;
+
+	angShellAngles.x = 0;
+	angShellAngles.z = 0;
+
+	CEffectData	data;
+	data.m_vStart	= vecShellVelocity;
+	data.m_vOrigin	= vecShellPosition;
+	data.m_vAngles	= angShellAngles;
+	data.m_fFlags	= iType;
+
+	DispatchEffect( "HL1ShellEject", data );
+}
+
+
+#ifdef CLIENT_DLL
+
+void CBaseHL1MPCombatWeapon::OnDataChanged( DataUpdateType_t type )
+{
+	BaseClass::OnDataChanged( type );
+
+	if ( GetPredictable() && !ShouldPredict() )
+		ShutdownPredictable();
+}
+
+
+bool CBaseHL1MPCombatWeapon::ShouldPredict()
+{
+	if ( GetOwner() && GetOwner() == C_BasePlayer::GetLocalPlayer() )
+		return true;
+
+	return BaseClass::ShouldPredict();
+}
+
+
+void CBaseHL1MPCombatWeapon::ApplyBoneMatrixTransform( matrix3x4_t& transform )
+{
+	BaseClass::ApplyBoneMatrixTransform( transform );
+}
+
+#endif
+
+
+bool CBaseHL1MPCombatWeapon::IsPredicted() const
+{ 
+	return true;
+}
+
+
+CBasePlayer* CBaseHL1MPCombatWeapon::GetPlayerOwner() const
+{
+	return dynamic_cast< CBasePlayer* >( GetOwner() );
+}
+
+
+void CBaseHL1MPCombatWeapon::WeaponSound( WeaponSound_t sound_type, float soundtime /* = 0.0f */ )
+{
+#ifdef CLIENT_DLL
+	// If we have some sounds from the weapon classname.txt file, play a random one of them
+	const char *shootsound = GetWpnData().aShootSounds[ sound_type ]; 
+	if ( !shootsound || !shootsound[0] )
+		return;
+
+	CBroadcastRecipientFilter filter; // this is client side only
+	if ( !te->CanPredict() )
+		return;
+				
+	CBaseEntity::EmitSound( filter, GetPlayerOwner()->entindex(), shootsound, &GetPlayerOwner()->GetAbsOrigin() ); 
+#else
+	BaseClass::WeaponSound( sound_type, soundtime );
+#endif
+}

game/shared/hl1/hl1mp_basecombatweapon_shared.h

@@ -0,0 +1,42 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+#include "hl1_basecombatweapon_shared.h"
+
+#ifndef BASEHL1MPCOMBATWEAPON_SHARED_H
+#define BASEHL1MPCOMBATWEAPON_SHARED_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#if defined( CLIENT_DLL )
+#define CBaseHL1MPCombatWeapon C_BaseHL1MPCombatWeapon
+#endif
+
+
+class CBaseHL1MPCombatWeapon : public CBaseHL1CombatWeapon
+{
+	DECLARE_CLASS( CBaseHL1MPCombatWeapon, CBaseHL1CombatWeapon );
+public :
+	CBaseHL1MPCombatWeapon();
+
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+public :
+	void EjectShell( CBaseEntity *pPlayer, int iType );
+
+	CBasePlayer* GetPlayerOwner() const;
+	virtual void WeaponSound( WeaponSound_t sound_type, float soundtime = 0.0f );
+
+#ifdef CLIENT_DLL
+	void OnDataChanged( DataUpdateType_t type );
+	bool ShouldPredict();
+
+	void ApplyBoneMatrixTransform( matrix3x4_t& transform );
+#endif
+	bool IsPredicted() const;
+
+};
+
+
+#endif	// #ifndef BASEHL1MPCOMBATWEAPON_SHARED_H

game/shared/hl1/hl1mp_gamerules.cpp

@@ -0,0 +1,739 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+#include "cbase.h"
+#include "hl1mp_gamerules.h"
+#include "viewport_panel_names.h"
+#include "gameeventdefs.h"
+#include <KeyValues.h>
+#include "ammodef.h"
+
+#ifdef CLIENT_DLL
+
+#include "hl1/c_hl1mp_player.h"
+
+#else
+
+#include "eventqueue.h"
+#include "player.h"
+#include "gamerules.h"
+#include "game.h"
+#include "items.h"
+#include "entitylist.h"
+#include "in_buttons.h"
+#include <ctype.h>
+#include "voice_gamemgr.h"
+#include "iscorer.h"
+#include "hl1mp_player.h"
+#include "team.h"
+#include "voice_gamemgr.h"
+
+#ifdef DEBUG	
+#include "hl1mp_bot_temp.h"
+#endif
+
+ConVar sv_hl1mp_weapon_respawn_time( "sv_hl1mp_weapon_respawn_time", "20", FCVAR_GAMEDLL | FCVAR_NOTIFY );
+ConVar sv_hl1mp_item_respawn_time( "sv_hl1mp_item_respawn_time", "30", FCVAR_GAMEDLL | FCVAR_NOTIFY );
+
+
+extern ConVar mp_chattime;
+
+extern CBaseEntity	 *g_pLastCombineSpawn;
+extern CBaseEntity	 *g_pLastRebelSpawn;
+
+//#define WEAPON_MAX_DISTANCE_FROM_SPAWN 64
+
+#endif
+
+
+REGISTER_GAMERULES_CLASS( CHL1MPRules );
+
+BEGIN_NETWORK_TABLE_NOBASE( CHL1MPRules, DT_HL1MPRules )
+
+	#ifdef CLIENT_DLL
+		RecvPropBool( RECVINFO( m_bTeamPlayEnabled ) ),
+	#else
+		SendPropBool( SENDINFO( m_bTeamPlayEnabled ) ),
+	#endif
+
+END_NETWORK_TABLE()
+
+
+LINK_ENTITY_TO_CLASS( hl1mp_gamerules, CHL1MPGameRulesProxy );
+IMPLEMENT_NETWORKCLASS_ALIASED( HL1MPGameRulesProxy, DT_HL1MPGameRulesProxy )
+
+
+#ifdef CLIENT_DLL
+	void RecvProxy_HL1MPRules( const RecvProp *pProp, void **pOut, void *pData, int objectID )
+	{
+		CHL1MPRules *pRules = HL1MPRules();
+		Assert( pRules );
+		*pOut = pRules;
+	}
+
+	BEGIN_RECV_TABLE( CHL1MPGameRulesProxy, DT_HL1MPGameRulesProxy )
+		RecvPropDataTable( "hl1mp_gamerules_data", 0, 0, &REFERENCE_RECV_TABLE( DT_HL1MPRules ), RecvProxy_HL1MPRules )
+	END_RECV_TABLE()
+#else
+	void* SendProxy_HL1MPRules( const SendProp *pProp, const void *pStructBase, const void *pData, CSendProxyRecipients *pRecipients, int objectID )
+	{
+		CHL1MPRules *pRules = HL1MPRules();
+		Assert( pRules );
+		return pRules;
+	}
+
+	BEGIN_SEND_TABLE( CHL1MPGameRulesProxy, DT_HL1MPGameRulesProxy )
+		SendPropDataTable( "hl1mp_gamerules_data", 0, &REFERENCE_SEND_TABLE( DT_HL1MPRules ), SendProxy_HL1MPRules )
+	END_SEND_TABLE()
+#endif
+
+#ifndef CLIENT_DLL
+
+#if 0
+	class CVoiceGameMgrHelper : public IVoiceGameMgrHelper
+	{
+	public:
+		virtual bool		CanPlayerHearPlayer( CBasePlayer *pListener, CBasePlayer *pTalker )
+		{
+			return ( pListener->GetTeamNumber() == pTalker->GetTeamNumber() );
+		}
+	};
+	CVoiceGameMgrHelper g_VoiceGameMgrHelper;
+	IVoiceGameMgrHelper *g_pVoiceGameMgrHelper = &g_VoiceGameMgrHelper;
+#endif
+
+#ifdef DEBUG
+
+	// Handler for the "bot" command.
+	void Bot_f()
+	{		
+		// Look at -count.
+		int count = 1;
+		count = clamp( count, 1, 16 );
+
+		int iTeam = 0;
+
+		// Look at -frozen.
+		bool bFrozen = false;
+
+		// Ok, spawn all the bots.
+		while ( --count >= 0 )
+		{
+			BotPutInServer( bFrozen, iTeam );
+		}
+	}
+
+
+	ConCommand cc_Bot( "bot", Bot_f, "Add a bot.", FCVAR_CHEAT );
+
+#endif
+
+#endif
+
+
+
+
+CHL1MPRules::CHL1MPRules()
+{
+#ifndef CLIENT_DLL
+	m_bTeamPlayEnabled = teamplay.GetBool();
+
+	if ( IsTeamplay() )
+	{
+		// Create basic server teams
+
+		CTeam *pTeam = static_cast<CTeam*>(CreateEntityByName( "team_manager" ));
+		pTeam->Init( "Unassigned", 0 );
+		g_Teams.AddToTail( pTeam );
+
+		pTeam = static_cast<CTeam*>(CreateEntityByName( "team_manager" ));
+		pTeam->Init( "Spectator", 1 );
+		g_Teams.AddToTail( pTeam );
+
+		char	*pName;
+		char	szTeamlist[TEAMPLAY_TEAMLISTLENGTH];
+
+		// loop through all teams, recounting everything
+		int num_teams = 0;
+
+		// Copy all of the teams from the teamlist
+		// make a copy because strtok is destructive
+		Q_strncpy( szTeamlist, teamlist.GetString(), sizeof(teamlist) );
+		pName = szTeamlist;
+		pName = strtok( pName, "," );
+		while ( pName != NULL && *pName )
+		{
+			if ( GetTeamIndex( pName ) < 0 )
+			{
+				// create team
+				pTeam = static_cast<CTeam*>(CreateEntityByName( "team_manager" ));
+				pTeam->Init( pName, num_teams + 2 );
+				g_Teams.AddToTail( pTeam );
+
+				num_teams++;
+			}
+			pName = strtok( NULL, "," );
+		}
+
+		// Manually create teams
+		if ( num_teams == 0 )
+		{
+			pTeam = static_cast<CTeam*>(CreateEntityByName( "team_manager" ) );
+			pTeam->Init( "robo", num_teams + 2 );
+			g_Teams.AddToTail( pTeam );
+			num_teams++;
+
+			pTeam = static_cast<CTeam*>(CreateEntityByName( "team_manager" ) );
+			pTeam->Init( "hgrunt", num_teams + 2 );
+			g_Teams.AddToTail( pTeam );
+			num_teams++;
+		}
+		
+	}
+#endif
+}
+
+CHL1MPRules::~CHL1MPRules( void )
+{
+#ifndef CLIENT_DLL
+	// Note, don't delete each team since they are in the gEntList and will 
+	// automatically be deleted from there, instead.
+	g_Teams.Purge();
+#endif
+}
+
+void CHL1MPRules::CreateStandardEntities( void )
+{
+
+#ifndef CLIENT_DLL
+	// Create the entity that will send our data to the client.
+
+	BaseClass::CreateStandardEntities();
+
+#ifdef _DEBUG
+	CBaseEntity *pEnt = 
+#endif
+	CBaseEntity::Create( "hl1mp_gamerules", vec3_origin, vec3_angle );
+	Assert( pEnt );
+#endif
+}
+
+float CHL1MPRules::GetAmmoDamage( CBaseEntity *pAttacker, CBaseEntity *pVictim, int nAmmoType )
+{
+    return BaseClass::GetAmmoDamage( pAttacker, pVictim, nAmmoType ) * GetDamageMultiplier();
+}
+
+float CHL1MPRules::GetDamageMultiplier( void )
+{
+    if ( IsMultiplayer() )
+        return sk_mp_dmg_multiplier.GetFloat();
+    else
+        return 1.0f;
+}
+
+
+bool CHL1MPRules::ClientCommand( CBaseEntity *pEdict, const CCommand &args )
+{
+#ifndef CLIENT_DLL
+	if( BaseClass::ClientCommand( pEdict, args ) )
+		return true;
+
+
+	CHL1MP_Player *pPlayer = (CHL1MP_Player *) pEdict;
+
+	if ( pPlayer->ClientCommand( args ) )
+		return true;
+#endif
+
+	return false;
+}
+
+
+#ifdef CLIENT_DLL
+#else
+
+
+void CHL1MPRules::Think ( void )
+{
+	CGameRules::Think();
+
+	if ( g_fGameOver )   // someone else quit the game already
+	{
+		// check to see if we should change levels now
+		if ( m_flIntermissionEndTime < gpGlobals->curtime )
+		{
+			ChangeLevel(); // intermission is over
+		}
+
+		return;
+	}
+
+	float flTimeLimit = mp_timelimit.GetFloat() * 60;
+	float flFragLimit = fraglimit.GetFloat();
+	
+	if ( flTimeLimit != 0 && gpGlobals->curtime >= flTimeLimit )
+	{
+		GoToIntermission();
+		return;
+	}
+
+	if ( flFragLimit )
+	{
+		if( IsTeamplay() == true )
+		{
+			for (int i = TEAM_SPECTATOR+1; i < GetNumberOfTeams(); i++)
+			{
+				if ( GetGlobalTeam(i)->GetScore() >= flFragLimit )
+				{
+					GoToIntermission();
+					return;
+				}
+			}
+		}
+		else
+		{
+			// check if any player is over the frag limit
+			for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+			{
+				CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
+
+				if ( pPlayer && pPlayer->FragCount() >= flFragLimit )
+				{
+					GoToIntermission();
+					return;
+				}
+			}
+		}
+	}
+
+//	ManageObjectRelocation();
+}
+
+
+void CHL1MPRules::GoToIntermission()
+{
+#ifndef CLIENT_DLL
+	if ( g_fGameOver )
+		return;
+
+	g_fGameOver = true;
+
+	m_flIntermissionEndTime = gpGlobals->curtime + mp_chattime.GetInt();
+
+	for ( int i = 0; i < MAX_PLAYERS; i++ )
+	{
+		CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
+
+		if ( !pPlayer )
+			continue;
+
+		pPlayer->ShowViewPortPanel( PANEL_SCOREBOARD );
+		pPlayer->AddFlag( FL_FROZEN );
+	}
+#endif
+}
+
+
+const char * CHL1MPRules::SetDefaultPlayerTeam( CBasePlayer *pPlayer )
+{
+	if ( !IsTeamplay() )
+	{
+		CMultiplayRules::SetDefaultPlayerTeam( pPlayer );
+		return "";
+	}
+
+	int clientIndex = pPlayer->entindex();
+	
+	char szTeam[128];
+	Q_FileBase( engine->GetClientConVarValue( clientIndex, "cl_playermodel" ), szTeam, 128 );
+
+	const char * team = szTeam;
+
+	int iTeam = GetTeamIndex( team );
+	if ( iTeam == -1 || !IsValidTeam( team ) )
+	{
+		team = TeamWithFewestPlayers();
+		iTeam = GetTeamIndex(team);
+	}
+
+	pPlayer->ChangeTeam( iTeam );
+
+	return team;
+}
+
+
+const char * CHL1MPRules::TeamWithFewestPlayers( void )
+{
+	const char * szName = "";
+	int iNumPlayers = 0xFFFF;
+	for (int i = TEAM_SPECTATOR+1; i < GetNumberOfTeams(); i++)
+	{
+		if ( GetGlobalTeam(i)->GetNumPlayers() < iNumPlayers )
+		{
+			szName = GetGlobalTeam(i)->GetName();
+			iNumPlayers = GetGlobalTeam(i)->GetNumPlayers();
+		}
+	}
+
+	return szName;
+}
+
+
+void CHL1MPRules::InitHUD( CBasePlayer *pPlayer )
+{
+	SetDefaultPlayerTeam( pPlayer );
+	BaseClass::InitHUD( pPlayer );
+}
+
+
+void CHL1MPRules::ChangePlayerTeam( CBasePlayer *pPlayer, const char *pTeamName, bool bKill, bool bGib )
+{
+	BaseClass::ChangePlayerTeam( pPlayer, pTeamName, bKill, bGib );
+}
+
+
+void CHL1MPRules::ClientSettingsChanged( CBasePlayer *pPlayer )
+{
+	CHL1MP_Player *pHL1Player = ToHL1MPPlayer( pPlayer );
+
+	if ( pHL1Player == NULL )
+		return;
+
+	// strip down to just the name
+	char szTempCurrentModel[128];
+	Q_FileBase( modelinfo->GetModelName( pPlayer->GetModel() ), szTempCurrentModel, 128 );
+	const char *pCurrentModel = szTempCurrentModel;
+
+	char szTempModelName[128];
+	Q_FileBase( engine->GetClientConVarValue( engine->IndexOfEdict( pPlayer->edict() ), "cl_playermodel" ), szTempModelName, 128 );	
+	const char *szModelName = szTempModelName;
+
+	//If we're different.
+	if ( strlen( szModelName ) > 0 && stricmp( szModelName, pCurrentModel ) )
+	{
+		//Too soon, set the cvar back to what it was.
+		//Note: this will make this function be called again
+		//but since our models will match it'll just skip this whole dealio.
+		if ( pHL1Player->GetNextModelChangeTime() >= gpGlobals->curtime )
+		{
+			char szReturnString[512];
+
+			Q_snprintf( szReturnString, sizeof (szReturnString ), "cl_playermodel %s\n", pCurrentModel );
+			engine->ClientCommand ( pHL1Player->edict(), szReturnString );
+
+			Q_snprintf( szReturnString, sizeof( szReturnString ), "Please wait %d more seconds before trying to switch.\n", (int)(pHL1Player->GetNextModelChangeTime() - gpGlobals->curtime) );
+			ClientPrint( pHL1Player, HUD_PRINTTALK, szReturnString );
+			return;
+		}
+
+		if ( HL1MPRules()->IsTeamplay() == false )
+		{
+			pHL1Player->SetPlayerModel();
+
+			//const char *pszCurrentModelName = modelinfo->GetModelName( pHL1Player->GetModel() );
+
+			//char szReturnString[128];
+			//Q_snprintf( szReturnString, sizeof( szReturnString ), "Your player model is: %s\n", pszCurrentModelName );
+
+			//Printing the model path for the average player is way too verbose - ml
+			//ClientPrint( pHL1Player, HUD_PRINTTALK, szReturnString );
+		}
+		else
+		{
+			int iTeam = GetTeamIndex( szModelName );
+			if ( iTeam == -1 || !IsValidTeam( szModelName ) )
+			{
+				const char * team = TeamWithFewestPlayers();
+				iTeam = GetTeamIndex( team );
+			}
+
+			pPlayer->ChangeTeam( iTeam );
+		}
+	}
+
+	BaseClass::ClientSettingsChanged( pPlayer );
+}
+
+
+int CHL1MPRules::GetTeamIndex( const char * pName )
+{
+	for ( int i = 0; i < GetNumberOfTeams(); i++ )
+	{
+		if ( strcmp( g_Teams[i]->GetName(), pName ) == 0 )
+		{
+			return i;
+		}
+	}
+
+	return -1;
+}
+
+
+float CHL1MPRules::FlWeaponRespawnTime( CBaseCombatWeapon *pWeapon )
+{
+	if ( weaponstay.GetInt() > 0 )
+	{
+		// make sure it's only certain weapons
+		if ( !(pWeapon->GetWeaponFlags() & ITEM_FLAG_LIMITINWORLD) )
+		{
+			return 0;
+		}
+	}
+
+	return sv_hl1mp_weapon_respawn_time.GetInt();
+}
+
+
+float CHL1MPRules::FlItemRespawnTime( CItem *pItem )
+{
+	return sv_hl1mp_item_respawn_time.GetInt();
+}
+
+
+
+// This is a direct rip from CHalfLife1
+void CHL1MPRules::InitDefaultAIRelationships( void )
+{
+	int i, j;
+
+	//  Allocate memory for default relationships
+	CBaseCombatCharacter::AllocateDefaultRelationships();
+
+	// --------------------------------------------------------------
+	// First initialize table so we can report missing relationships
+	// --------------------------------------------------------------
+	for (i=0;i<NUM_AI_CLASSES;i++)
+	{
+		for (j=0;j<NUM_AI_CLASSES;j++)
+		{
+			// By default all relationships are neutral of priority zero
+			CBaseCombatCharacter::SetDefaultRelationship( (Class_T)i, (Class_T)j, D_NU, 0 );
+		}
+	}
+
+	// ------------------------------------------------------------
+	//	> CLASS_NONE
+	// ------------------------------------------------------------
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_NONE,				D_NU, 0 );			
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_PLAYER,			D_NU, 0 );			
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_HUMAN_PASSIVE,	D_NU, 0 );		
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_PLAYER_ALLY,		D_NU, 0 );		
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_ALIEN_PREY,		D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_ALIEN_MILITARY,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_ALIEN_MONSTER,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_ALIEN_PREDATOR,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_HUMAN_MILITARY,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_MACHINE,			D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_ALIEN_BIOWEAPON,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_PLAYER_BIOWEAPON,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_NONE,				CLASS_INSECT,			D_NU, 0 );
+
+
+	// ------------------------------------------------------------
+	//	> CLASS_HUMAN_PASSIVE
+	// ------------------------------------------------------------
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_NONE,				D_NU, 0 );			
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_PLAYER,			D_LI, 0 );	
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_HUMAN_PASSIVE,	D_LI, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_PLAYER_ALLY,		D_LI, 0 );	
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_ALIEN_PREY,		D_FR, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_ALIEN_MILITARY,	D_FR, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_ALIEN_MONSTER,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_ALIEN_PREDATOR,	D_FR, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_HUMAN_MILITARY,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_MACHINE,			D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_ALIEN_BIOWEAPON,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_PLAYER_BIOWEAPON,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_PASSIVE,		CLASS_INSECT,			D_NU, 0 );
+
+
+
+	// ------------------------------------------------------------
+	//	> CLASS_PLAYER
+	// ------------------------------------------------------------
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,				CLASS_NONE,				D_NU, 0 );			
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,				CLASS_PLAYER,			D_LI, 0 );			
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,				CLASS_HUMAN_PASSIVE,	D_LI, 0 );	
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,				CLASS_PLAYER_ALLY,		D_LI, 0 );	
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,		  	    CLASS_ALIEN_PREY,		D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,		  	    CLASS_ALIEN_MILITARY,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,				CLASS_ALIEN_MONSTER,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,				CLASS_ALIEN_PREDATOR,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,				CLASS_HUMAN_MILITARY,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,				CLASS_MACHINE,			D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,				CLASS_ALIEN_BIOWEAPON,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,				CLASS_PLAYER_BIOWEAPON,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER,				CLASS_INSECT,			D_NU, 0 );
+
+	// ------------------------------------------------------------
+	//	> CLASS_PLAYER_ALLY
+	// ------------------------------------------------------------
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_NONE,				D_NU, 0 );			
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_PLAYER,			D_LI, 0 );			
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_HUMAN_PASSIVE,	D_LI, 0 );	
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_PLAYER_ALLY,		D_LI, 0 );	
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_ALIEN_PREY,		D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_ALIEN_MILITARY,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_ALIEN_MONSTER,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_ALIEN_PREDATOR,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_HUMAN_MILITARY,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_MACHINE,			D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_ALIEN_BIOWEAPON,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_PLAYER_BIOWEAPON,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_ALLY,		CLASS_INSECT,			D_NU, 0 );
+
+	// ------------------------------------------------------------
+	//	> CLASS_ALIEN_PREY
+	// ------------------------------------------------------------
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_NONE,				D_NU, 0 );			
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_PLAYER,			D_HT, 0 );			
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_PLAYER_ALLY,		D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_HUMAN_PASSIVE,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_ALIEN_PREY,		D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_ALIEN_MILITARY,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_ALIEN_MONSTER,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_ALIEN_PREDATOR,	D_FR, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_HUMAN_MILITARY,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_MACHINE,			D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_ALIEN_BIOWEAPON,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_PLAYER_BIOWEAPON,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREY,			CLASS_INSECT,			D_NU, 0 );
+
+	// ------------------------------------------------------------
+	//	> CLASS_ALIEN_MILITARY
+	// ------------------------------------------------------------
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_NONE,				D_NU, 0 );			
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_PLAYER,			D_HT, 0 );			
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_PLAYER_ALLY,		D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_HUMAN_PASSIVE,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_ALIEN_PREY,		D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_ALIEN_MILITARY,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_ALIEN_MONSTER,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_ALIEN_PREDATOR,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_HUMAN_MILITARY,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_MACHINE,			D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_ALIEN_BIOWEAPON,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_PLAYER_BIOWEAPON,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MILITARY,		CLASS_INSECT,			D_NU, 0 );
+
+	// ------------------------------------------------------------
+	//	> CLASS_ALIEN_MONSTER
+	// ------------------------------------------------------------
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_NONE,				D_NU, 0 );			
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_PLAYER,			D_HT, 0 );			
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_PLAYER_ALLY,		D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_HUMAN_PASSIVE,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_ALIEN_PREY,		D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_ALIEN_MILITARY,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_ALIEN_MONSTER,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_ALIEN_PREDATOR,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_HUMAN_MILITARY,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_MACHINE,			D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_ALIEN_BIOWEAPON,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_PLAYER_BIOWEAPON,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_MONSTER,		CLASS_INSECT,			D_NU, 0 );
+
+	// ------------------------------------------------------------
+	//	> CLASS_ALIEN_PREDATOR
+	// ------------------------------------------------------------
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_NONE,				D_NU, 0 );			
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_PLAYER,			D_HT, 0 );			
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_PLAYER_ALLY,		D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_HUMAN_PASSIVE,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_ALIEN_PREY,		D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_ALIEN_MILITARY,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_ALIEN_MONSTER,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_ALIEN_PREDATOR,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_HUMAN_MILITARY,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_MACHINE,			D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_ALIEN_BIOWEAPON,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_PLAYER_BIOWEAPON,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_PREDATOR,		CLASS_INSECT,			D_NU, 0 );
+
+	// ------------------------------------------------------------
+	//	> CLASS_HUMAN_MILITARY
+	// ------------------------------------------------------------
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_NONE,				D_NU, 0 );			
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_PLAYER,			D_HT, 0 );			
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_PLAYER_ALLY,		D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_HUMAN_PASSIVE,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_ALIEN_PREY,		D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_ALIEN_MILITARY,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_ALIEN_MONSTER,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_ALIEN_PREDATOR,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_HUMAN_MILITARY,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_MACHINE,			D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_ALIEN_BIOWEAPON,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_PLAYER_BIOWEAPON,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_HUMAN_MILITARY,		CLASS_INSECT,			D_NU, 0 );
+
+	// ------------------------------------------------------------
+	//	> CLASS_MACHINE
+	// ------------------------------------------------------------
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_NONE,				D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_MACHINE,			D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_PLAYER,			D_HT, 0 );			
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_HUMAN_PASSIVE,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_HUMAN_MILITARY,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_ALIEN_MILITARY,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_ALIEN_MONSTER,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_ALIEN_PREY,		D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_ALIEN_PREDATOR,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_PLAYER_ALLY,		D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_ALIEN_BIOWEAPON,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_PLAYER_BIOWEAPON,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_MACHINE,			CLASS_INSECT,			D_NU, 0 );
+
+	// ------------------------------------------------------------
+	//	> CLASS_ALIEN_BIOWEAPON
+	// ------------------------------------------------------------
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_NONE,				D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_MACHINE,			D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_PLAYER,			D_HT, 0 );			
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_HUMAN_PASSIVE,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_HUMAN_MILITARY,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_ALIEN_MILITARY,	D_LI, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_ALIEN_MONSTER,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_ALIEN_PREY,		D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_ALIEN_PREDATOR,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_PLAYER_ALLY,		D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_ALIEN_BIOWEAPON,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_PLAYER_BIOWEAPON,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_ALIEN_BIOWEAPON,	CLASS_INSECT,			D_NU, 0 );
+
+	// ------------------------------------------------------------
+	//	> CLASS_PLAYER_BIOWEAPON
+	// ------------------------------------------------------------
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_NONE,				D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_MACHINE,			D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_PLAYER,			D_HT, 0 );			
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_HUMAN_PASSIVE,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_HUMAN_MILITARY,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_ALIEN_MILITARY,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_ALIEN_MONSTER,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_ALIEN_PREY,		D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_ALIEN_PREDATOR,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_PLAYER_ALLY,		D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_ALIEN_BIOWEAPON,	D_HT, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_PLAYER_BIOWEAPON,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_PLAYER_BIOWEAPON,	CLASS_INSECT,			D_NU, 0 );
+
+
+	// ------------------------------------------------------------
+	//	> CLASS_INSECT
+	// ------------------------------------------------------------
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_NONE,				D_FR, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_MACHINE,			D_FR, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_PLAYER,			D_FR, 0 );			
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_HUMAN_PASSIVE,	D_FR, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_HUMAN_MILITARY,	D_FR, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_ALIEN_MILITARY,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_ALIEN_MONSTER,	D_FR, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_ALIEN_PREY,		D_FR, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_ALIEN_PREDATOR,	D_FR, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_PLAYER_ALLY,		D_FR, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_ALIEN_BIOWEAPON,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_PLAYER_BIOWEAPON,	D_NU, 0 );
+	CBaseCombatCharacter::SetDefaultRelationship( CLASS_INSECT,				CLASS_INSECT,			D_NU, 0 );
+}
+
+
+#endif

game/shared/hl1/hl1mp_gamerules.h

@@ -0,0 +1,91 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+#ifndef HL1MP_GAMERULES_H
+#define HL1MP_GAMERULES_H
+#pragma once
+
+
+#include "gamerules.h"
+#include "teamplay_gamerules.h"
+
+extern ConVar sk_mp_dmg_multiplier ;
+
+#ifdef CLIENT_DLL
+	#define CHL1MPRules C_HL1MPRules
+	#define CHL1MPGameRulesProxy C_HL1MPGameRulesProxy
+#endif
+
+
+class CHL1MPGameRulesProxy : public CGameRulesProxy
+{
+public:
+	DECLARE_CLASS( CHL1MPGameRulesProxy, CGameRulesProxy );
+	DECLARE_NETWORKCLASS();
+};
+
+
+class CHL1MPRules : public CTeamplayRules
+{
+public:
+	DECLARE_CLASS( CHL1MPRules, CTeamplayRules );
+
+#ifdef CLIENT_DLL
+	DECLARE_CLIENTCLASS_NOBASE();
+#else
+	DECLARE_SERVERCLASS_NOBASE();
+#endif
+
+	CHL1MPRules();
+	virtual ~CHL1MPRules();
+
+	virtual void CreateStandardEntities( void );
+
+	virtual bool IsTeamplay( void )
+	{
+		return m_bTeamPlayEnabled;
+	}
+
+	virtual float GetAmmoDamage( CBaseEntity *pAttacker, CBaseEntity *pVictim, int nAmmoType );
+    virtual float GetDamageMultiplier( void );    
+
+	virtual bool IsConnectedUserInfoChangeAllowed( CBasePlayer *pPlayer )
+	{ 
+		return true; 
+	}
+	bool ClientCommand( CBaseEntity *pEdict, const CCommand &args );
+
+#ifdef CLIENT_DLL
+#else
+	virtual const char *GetGameDescription( void ) { return "Half-Life Deathmatch: Source"; }  // this is the game name that gets seen in the server browser
+
+	virtual void Think ( void );
+
+	virtual void GoToIntermission( void );
+
+	virtual void InitDefaultAIRelationships( void );
+
+	virtual float FlWeaponRespawnTime( CBaseCombatWeapon *pWeapon );
+	virtual float FlItemRespawnTime( CItem *pItem );
+
+	virtual const char *SetDefaultPlayerTeam( CBasePlayer *pPlayer );
+	virtual void InitHUD( CBasePlayer *pPlayer );
+	virtual void ChangePlayerTeam( CBasePlayer *pPlayer, const char *pTeamName, bool bKill, bool bGib );
+	virtual void ClientSettingsChanged( CBasePlayer *pPlayer );
+
+	virtual int GetTeamIndex( const char * pName );
+#endif
+
+private:
+
+	const char *TeamWithFewestPlayers( void );
+
+	CNetworkVar( bool, m_bTeamPlayEnabled );
+};
+
+
+inline CHL1MPRules* HL1MPRules()
+{
+	return dynamic_cast<CHL1MPRules*>(g_pGameRules);
+}
+
+
+#endif

game/shared/hl1/hl1mp_weapon_357.cpp

@@ -0,0 +1,289 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:		357 - hand gun
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "npcevent.h"
+#include "hl1mp_basecombatweapon_shared.h"
+#ifdef CLIENT_DLL
+#include "c_baseplayer.h"
+#else
+#include "player.h"
+#endif
+#include "gamerules.h"
+#include "in_buttons.h"
+#ifndef CLIENT_DLL
+#include "soundent.h"
+#include "game.h"
+#endif
+#include "vstdlib/random.h"
+#include "engine/IEngineSound.h"
+
+#ifdef CLIENT_DLL
+#define CWeapon357 C_Weapon357
+#endif
+
+//-----------------------------------------------------------------------------
+// CWeapon357
+//-----------------------------------------------------------------------------
+
+class CWeapon357 : public CBaseHL1MPCombatWeapon
+{
+	DECLARE_CLASS( CWeapon357, CBaseHL1CombatWeapon );
+public:
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+
+	CWeapon357( void );
+
+	void	Precache( void );
+	bool	Deploy( void );
+	void	PrimaryAttack( void );
+	void	SecondaryAttack( void );
+	bool	Reload( void );
+	void	WeaponIdle( void );
+	bool	Holster( CBaseCombatWeapon *pSwitchingTo = NULL );
+
+//	DECLARE_SERVERCLASS();
+//	DECLARE_DATADESC();
+
+private:
+	void	ToggleZoom( void );
+
+private:
+	CNetworkVar( float, m_fInZoom );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( Weapon357, DT_Weapon357 );
+
+BEGIN_NETWORK_TABLE( CWeapon357, DT_Weapon357 )
+#ifdef CLIENT_DLL
+	RecvPropFloat( RECVINFO( m_fInZoom ) ),
+#else
+	SendPropFloat( SENDINFO( m_fInZoom ) ),
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeapon357 )
+#ifdef CLIENT_DLL
+	DEFINE_PRED_FIELD( m_fInZoom, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
+#endif
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_357, CWeapon357 );
+
+PRECACHE_WEAPON_REGISTER( weapon_357 );
+
+//IMPLEMENT_SERVERCLASS_ST( CWeapon357, DT_Weapon357 )
+//END_SEND_TABLE()
+
+//BEGIN_DATADESC( CWeapon357 )
+//END_DATADESC()
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CWeapon357::CWeapon357( void )
+{
+	m_bReloadsSingly	= false;
+	m_bFiresUnderwater	= false;
+	m_fInZoom			= false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeapon357::Precache( void )
+{
+	BaseClass::Precache();
+
+#ifndef CLIENT_DLL
+	UTIL_PrecacheOther( "ammo_357" );
+#endif
+}
+
+bool CWeapon357::Deploy( void )
+{
+// Bodygroup stuff not currently working correctly
+//	if ( g_pGameRules->IsMultiplayer() )
+//	{
+		// enable laser sight geometry.
+//		SetBodygroup( 4, 1 );
+//	}
+//	else
+//	{
+//		SetBodygroup( 4, 0 );
+//	}
+
+	return BaseClass::Deploy();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CWeapon357::PrimaryAttack( void )
+{
+	// Only the player fires this way so we can cast
+	CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
+
+	if ( !pPlayer )
+	{
+		return;
+	}
+
+	if ( m_iClip1 <= 0 )
+	{
+		if ( !m_bFireOnEmpty )
+		{
+			Reload();
+		}
+		else
+		{
+			WeaponSound( EMPTY );
+			m_flNextPrimaryAttack = 0.15;
+		}
+
+		return;
+	}
+
+	WeaponSound( SINGLE );
+	pPlayer->DoMuzzleFlash();
+
+	SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+	pPlayer->SetAnimation( PLAYER_ATTACK1 );
+
+	m_flNextPrimaryAttack = gpGlobals->curtime + 0.75;
+	m_flNextSecondaryAttack = gpGlobals->curtime + 0.75;
+
+	m_iClip1--;
+
+	Vector vecSrc		= pPlayer->Weapon_ShootPosition();
+	Vector vecAiming	= pPlayer->GetAutoaimVector( AUTOAIM_5DEGREES );	
+
+//	pPlayer->FireBullets( 1, vecSrc, vecAiming, VECTOR_CONE_1DEGREES, MAX_TRACE_LENGTH, m_iPrimaryAmmoType, 0 );
+
+	FireBulletsInfo_t info( 1, vecSrc, vecAiming, VECTOR_CONE_1DEGREES, MAX_TRACE_LENGTH, m_iPrimaryAmmoType );
+	info.m_pAttacker = pPlayer;
+
+	pPlayer->FireBullets( info );
+
+#ifndef CLIENT_DLL
+	pPlayer->SetMuzzleFlashTime( gpGlobals->curtime + 0.5 );
+#endif
+
+	pPlayer->ViewPunch( QAngle( -10, 0, 0 ) );
+
+#ifndef CLIENT_DLL
+	CSoundEnt::InsertSound( SOUND_COMBAT, GetAbsOrigin(), 600, 0.2 );
+#endif
+
+	if ( !m_iClip1 && pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 )
+	{
+		// HEV suit - indicate out of ammo condition
+		pPlayer->SetSuitUpdate( "!HEV_AMO0", FALSE, 0 ); 
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CWeapon357::SecondaryAttack( void )
+{
+	// only in multiplayer
+	if ( !g_pGameRules->IsMultiplayer() )
+	{
+#ifndef CLIENT_DLL
+		// unless we have cheats on
+		if ( !sv_cheats->GetBool() )
+		{
+			return;
+		}
+#endif
+	}
+
+	ToggleZoom();
+
+	m_flNextSecondaryAttack = gpGlobals->curtime + 0.5;
+}
+
+
+bool CWeapon357::Reload( void )
+{
+	bool fRet;
+
+	fRet = DefaultReload( GetMaxClip1(), GetMaxClip2(), ACT_VM_RELOAD );
+	if ( fRet )
+	{
+		if ( m_fInZoom )
+		{
+			ToggleZoom();
+		}
+	}
+
+	return fRet;
+}
+
+
+void CWeapon357::WeaponIdle( void )
+{
+	CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
+	if ( pPlayer )
+	{
+		pPlayer->GetAutoaimVector( AUTOAIM_10DEGREES );
+	}
+
+	if ( !HasWeaponIdleTimeElapsed() )
+		return;
+
+	if ( random->RandomFloat( 0, 1 ) <= 0.9 )
+	{
+		SendWeaponAnim( ACT_VM_IDLE );
+	}
+	else
+	{
+		SendWeaponAnim( ACT_VM_FIDGET );
+	}
+}
+
+
+bool CWeapon357::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+	if ( m_fInZoom )
+	{
+		ToggleZoom();
+	}
+
+	return BaseClass::Holster( pSwitchingTo );
+}
+
+
+void CWeapon357::ToggleZoom( void )
+{
+	CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
+	if ( !pPlayer )
+	{
+		return;
+	}
+
+#ifndef CLIENT_DLL
+	if ( m_fInZoom )
+	{
+		if ( pPlayer->SetFOV( this, 0 ) )
+		{
+			m_fInZoom = false;
+			pPlayer->ShowViewModel( true );
+		}
+	}
+	else
+	{
+		if ( pPlayer->SetFOV( this, 40 ) )
+		{
+			m_fInZoom = true;
+			pPlayer->ShowViewModel( false );
+		}
+	}
+#endif
+}

game/shared/hl1/hl1mp_weapon_crossbow.cpp

@@ -0,0 +1,648 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:		Crossbow
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "npcevent.h"
+#include "hl1mp_basecombatweapon_shared.h"
+//#include "basecombatcharacter.h"
+//#include "AI_BaseNPC.h"
+#ifdef CLIENT_DLL
+#include "c_baseplayer.h"
+#else
+#include "player.h"
+#endif
+//#include "player.h"
+#include "gamerules.h"
+#include "in_buttons.h"
+#ifdef CLIENT_DLL
+#else
+#include "soundent.h"
+#include "entitylist.h"
+#include "game.h"
+#endif
+#include "vstdlib/random.h"
+#include "engine/IEngineSound.h"
+#include "IEffects.h"
+#ifdef CLIENT_DLL
+#include "c_te_effect_dispatch.h"
+#else
+#include "te_effect_dispatch.h"
+#endif
+
+#define BOLT_MODEL			"models/crossbow_bolt.mdl"
+
+#define BOLT_AIR_VELOCITY	2000
+#define BOLT_WATER_VELOCITY	1000
+
+extern ConVar sk_plr_dmg_xbow_bolt_plr;
+extern ConVar sk_plr_dmg_xbow_bolt_npc;
+
+extern short	g_sModelIndexFireball;		// (in combatweapon.cpp) holds the index for the fireball 
+
+#if !defined(CLIENT_DLL)
+
+//-----------------------------------------------------------------------------
+// Crossbow Bolt
+//-----------------------------------------------------------------------------
+class CCrossbowBolt : public CBaseCombatCharacter
+{
+	DECLARE_CLASS( CCrossbowBolt, CBaseCombatCharacter );
+
+public:
+	CCrossbowBolt()
+    {
+        m_bExplode = true;
+    }
+
+	Class_T Classify( void ) { return CLASS_NONE; }
+
+public:
+	void Spawn( void );
+	void Precache( void );
+	void BubbleThink( void );
+	void BoltTouch( CBaseEntity *pOther );
+    void ExplodeThink( void );
+    void SetExplode( bool bVal ) { m_bExplode = bVal; }
+	bool CreateVPhysics( void );
+	unsigned int PhysicsSolidMaskForEntity() const;
+
+	static CCrossbowBolt *BoltCreate( const Vector &vecOrigin, const QAngle &angAngles, CBasePlayer *pentOwner = NULL );
+
+	DECLARE_DATADESC();
+
+private:
+    bool m_bExplode;
+};
+LINK_ENTITY_TO_CLASS( crossbow_bolt, CCrossbowBolt );
+
+BEGIN_DATADESC( CCrossbowBolt )
+	// Function Pointers
+	DEFINE_FUNCTION( BubbleThink ),
+	DEFINE_FUNCTION( BoltTouch ),
+    DEFINE_FUNCTION( ExplodeThink ),
+END_DATADESC()
+
+CCrossbowBolt *CCrossbowBolt::BoltCreate( const Vector &vecOrigin, const QAngle &angAngles, CBasePlayer *pentOwner )
+{
+	// Create a new entity with CCrossbowBolt private data
+	CCrossbowBolt *pBolt = (CCrossbowBolt *)CreateEntityByName( "crossbow_bolt" );
+	UTIL_SetOrigin( pBolt, vecOrigin );
+	pBolt->SetAbsAngles( angAngles );
+	pBolt->Spawn();
+	pBolt->SetOwnerEntity( pentOwner );
+
+	return pBolt;
+}
+
+void CCrossbowBolt::Spawn( )
+{
+	Precache( );
+
+	SetModel( BOLT_MODEL );
+	UTIL_SetSize( this, -Vector(1, 1, 1), Vector(1, 1, 1) );
+
+	SetSolid( SOLID_BBOX );
+	SetMoveType( MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_BOUNCE );
+	SetGravity( UTIL_ScaleForGravity( 40 ) );	// use a really low gravity (40 in/s^2)
+
+	SetTouch( &CCrossbowBolt::BoltTouch );
+
+	SetThink( &CCrossbowBolt::BubbleThink );
+	SetNextThink( gpGlobals->curtime + 0.2 );
+
+    m_bExplode = true;
+}
+
+
+void CCrossbowBolt::Precache( )
+{
+	PrecacheModel( BOLT_MODEL );
+	PrecacheScriptSound( "BaseGrenade.Explode" );    
+}
+
+void CCrossbowBolt::BoltTouch( CBaseEntity *pOther )
+{
+	if ( !pOther->IsSolid() || pOther->IsSolidFlagSet(FSOLID_VOLUME_CONTENTS) )
+		return;
+
+	SetTouch( NULL );
+	SetThink( NULL );
+
+	if ( pOther->m_takedamage != DAMAGE_NO )
+	{
+		trace_t tr, tr2;
+		tr = BaseClass::GetTouchTrace( );
+		Vector	vecNormalizedVel = GetAbsVelocity();
+
+		ClearMultiDamage( );
+		VectorNormalize( vecNormalizedVel );
+
+		if ( pOther->IsPlayer() )
+		{
+            float m_fDamage = sk_plr_dmg_xbow_bolt_plr.GetFloat() * g_pGameRules->GetDamageMultiplier();
+
+            // If multiplayer sniper bolt, multiply damage by 4
+            if ( g_pGameRules->IsMultiplayer() && !m_bExplode )
+                m_fDamage *= 4;
+            
+			CTakeDamageInfo	dmgInfo( this, GetOwnerEntity(), m_fDamage,DMG_NEVERGIB );
+			CalculateMeleeDamageForce( &dmgInfo, vecNormalizedVel, tr.endpos );
+			pOther->DispatchTraceAttack( dmgInfo, vecNormalizedVel, &tr );
+		}
+		else
+		{
+			CTakeDamageInfo	dmgInfo( this, GetOwnerEntity(), sk_plr_dmg_xbow_bolt_npc.GetFloat() * g_pGameRules->GetDamageMultiplier(), DMG_BULLET | DMG_NEVERGIB );
+			CalculateMeleeDamageForce( &dmgInfo, vecNormalizedVel, tr.endpos );
+			pOther->DispatchTraceAttack( dmgInfo, vecNormalizedVel, &tr );
+		}
+
+		ApplyMultiDamage();
+
+		SetAbsVelocity( Vector( 0, 0, 0 ) );
+
+		// play body "thwack" sound
+		EmitSound( "Weapon_Crossbow.BoltHitBody" );
+
+		Vector vForward;
+
+		AngleVectors( GetAbsAngles(), &vForward );
+		VectorNormalize ( vForward );
+		
+		UTIL_TraceLine( GetAbsOrigin(),	GetAbsOrigin() + vForward * 128, MASK_OPAQUE, pOther, COLLISION_GROUP_NONE, &tr2 );
+
+		if ( tr2.fraction != 1.0f )
+		{
+//			NDebugOverlay::Box( tr2.endpos, Vector( -16, -16, -16 ), Vector( 16, 16, 16 ), 0, 255, 0, 0, 10 );
+//			NDebugOverlay::Box( GetAbsOrigin(), Vector( -16, -16, -16 ), Vector( 16, 16, 16 ), 0, 0, 255, 0, 10 );
+
+			CEffectData	data;
+
+			data.m_vOrigin = tr2.endpos;
+			data.m_vNormal = vForward;
+			data.m_nEntIndex = tr2.fraction != 1.0f;
+		
+			DispatchEffect( "BoltImpact", data );
+		}
+
+        if ( !g_pGameRules->IsMultiplayer() || !m_bExplode )
+		{
+			UTIL_Remove( this );
+		}
+	}
+	else
+	{
+		EmitSound( "Weapon_Crossbow.BoltHitWorld" );
+
+		SetThink( &CCrossbowBolt::SUB_Remove );
+		SetNextThink( gpGlobals->curtime );// this will get changed below if the bolt is allowed to stick in what it hit.
+
+		if ( m_bExplode == false )
+		{
+			Vector vForward;
+			AngleVectors( GetAbsAngles(), &vForward );
+			VectorNormalize ( vForward );
+
+			CEffectData	data;
+
+			data.m_vOrigin = GetAbsOrigin();
+			data.m_vNormal = vForward;
+			data.m_nEntIndex = 0;
+
+			DispatchEffect( "BoltImpact", data );
+		}
+
+		if (  UTIL_PointContents( GetAbsOrigin() ) != CONTENTS_WATER)
+		{
+			g_pEffects->Sparks( GetAbsOrigin() );
+		}
+	}
+
+    // Set up an explosion in one tenth of a second
+	if ( g_pGameRules->IsMultiplayer() && m_bExplode )
+	{
+        SetThink( &CCrossbowBolt::ExplodeThink );
+        SetNextThink( gpGlobals->curtime + 0.1f );
+	}
+}
+
+void CCrossbowBolt::ExplodeThink( void )
+{
+    //    int iContents = UTIL_PointContents( pev->origin );
+    CTakeDamageInfo	dmgInfo( this, GetOwnerEntity(), sk_plr_dmg_xbow_bolt_npc.GetFloat() * g_pGameRules->GetDamageMultiplier(), DMG_BLAST );
+
+    ::RadiusDamage( dmgInfo, GetAbsOrigin(), 128, CLASS_NONE, NULL );
+
+#if !defined( CLIENT_DLL )
+    CPASFilter filter( GetAbsOrigin() );
+
+    te->Explosion( filter,                /* filter */
+                   0.0,                   /* delay  */
+                   &GetAbsOrigin(),       /* pos    */
+                   g_sModelIndexFireball, /* modelindex */
+                   0.2,                   /* scale  */
+                   25,                    /* framerate */
+                   TE_EXPLFLAG_NONE,      /* flags */
+                   128,                   /* radius */
+                   64,                    /* magnitude */
+                   NULL,                  /* normal */
+                   'C' );                 /* materialType */
+
+	//CSoundEnt::InsertSound ( SOUND_COMBAT, GetAbsOrigin(), BASEGRENADE_EXPLOSION_VOLUME, 3.0 );
+	EmitSound( "BaseGrenade.Explode" );    
+#endif
+
+    
+    SetThink( &CCrossbowBolt::SUB_Remove );
+    SetNextThink( gpGlobals->curtime );
+    
+    AddEffects( EF_NODRAW );
+}
+
+void CCrossbowBolt::BubbleThink( void )
+{
+	QAngle angNewAngles;
+
+	VectorAngles( GetAbsVelocity(), angNewAngles );
+	SetAbsAngles( angNewAngles );
+
+	SetNextThink( gpGlobals->curtime + 0.1f );
+
+	if ( GetWaterLevel()  == 0 )
+		return;
+
+	UTIL_BubbleTrail( GetAbsOrigin() - GetAbsVelocity() * 0.1, GetAbsOrigin(), 1 );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CCrossbowBolt::CreateVPhysics( void )
+{
+	// Create the object in the physics system
+	VPhysicsInitNormal( SOLID_BBOX, FSOLID_NOT_STANDABLE, false );
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+unsigned int CCrossbowBolt::PhysicsSolidMaskForEntity() const
+{
+	return ( BaseClass::PhysicsSolidMaskForEntity() | CONTENTS_HITBOX ) & ~CONTENTS_GRATE;
+}
+
+
+#endif	// crossbowbolt
+
+//-----------------------------------------------------------------------------
+// CWeaponCrossbow
+//-----------------------------------------------------------------------------
+
+#ifdef CLIENT_DLL
+#define CWeaponCrossbow C_WeaponCrossbow
+#endif
+
+class CWeaponCrossbow : public CBaseHL1MPCombatWeapon
+{
+	DECLARE_CLASS( CWeaponCrossbow, CBaseHL1MPCombatWeapon );
+public:
+
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+
+	CWeaponCrossbow( void );
+
+	void	Precache( void );
+	void	PrimaryAttack( void );
+	void	SecondaryAttack( void );
+	bool	Reload( void );
+	void	WeaponIdle( void );
+	bool	Deploy( void );
+	bool	Holster( CBaseCombatWeapon *pSwitchingTo = NULL );
+
+//	DECLARE_SERVERCLASS();
+	DECLARE_DATADESC();
+
+#ifndef CLIENT_DLL
+//	DECLARE_ACTTABLE();
+#endif
+
+private:
+	void	FireBolt( void );
+	void	ToggleZoom( void );
+
+private:
+//	bool	m_fInZoom;
+	CNetworkVar( bool, m_fInZoom );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponCrossbow, DT_WeaponCrossbow );
+
+BEGIN_NETWORK_TABLE( CWeaponCrossbow, DT_WeaponCrossbow )
+#ifdef CLIENT_DLL
+	RecvPropBool( RECVINFO( m_fInZoom ) ),
+#else
+	SendPropBool( SENDINFO( m_fInZoom ) ),
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponCrossbow )
+#ifdef CLIENT_DLL
+	DEFINE_PRED_FIELD( m_fInZoom, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+#endif
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_crossbow, CWeaponCrossbow );
+
+PRECACHE_WEAPON_REGISTER( weapon_crossbow );
+
+//IMPLEMENT_SERVERCLASS_ST( CWeaponCrossbow, DT_WeaponCrossbow )
+//END_SEND_TABLE()
+
+BEGIN_DATADESC( CWeaponCrossbow )
+END_DATADESC()
+
+#if 0
+#ifndef CLIENT_DLL
+
+acttable_t	CWeaponCrossbow::m_acttable[] = 
+{
+	{ ACT_HL2MP_IDLE,					ACT_HL2MP_IDLE_CROSSBOW,					false },
+//	{ ACT_HL2MP_RUN,					ACT_HL2MP_RUN_CROSSBOW,						false },
+//	{ ACT_HL2MP_IDLE_CROUCH,			ACT_HL2MP_IDLE_CROUCH_CROSSBOW,				false },
+//	{ ACT_HL2MP_WALK_CROUCH,			ACT_HL2MP_WALK_CROUCH_CROSSBOW,				false },
+//	{ ACT_HL2MP_GESTURE_RANGE_ATTACK,	ACT_HL2MP_GESTURE_RANGE_ATTACK_CROSSBOW,	false },
+//	{ ACT_HL2MP_GESTURE_RELOAD,			ACT_HL2MP_GESTURE_RELOAD_CROSSBOW,			false },
+//	{ ACT_HL2MP_JUMP,					ACT_HL2MP_JUMP_CROSSBOW,					false },
+};
+
+IMPLEMENT_ACTTABLE(CWeaponCrossbow);
+
+#endif
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CWeaponCrossbow::CWeaponCrossbow( void )
+{
+	m_bReloadsSingly	= false;
+	m_bFiresUnderwater	= true;
+	m_fInZoom			= false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCrossbow::Precache( void )
+{
+#ifndef CLIENT_DLL
+	UTIL_PrecacheOther( "crossbow_bolt" );
+#endif
+
+	PrecacheScriptSound( "Weapon_Crossbow.BoltHitBody" );
+	PrecacheScriptSound( "Weapon_Crossbow.BoltHitWorld" );
+
+	BaseClass::Precache();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CWeaponCrossbow::PrimaryAttack( void )
+{
+	if ( m_fInZoom && g_pGameRules->IsMultiplayer() )
+	{
+//		FireSniperBolt();
+		FireBolt();
+	}
+	else
+	{
+		FireBolt();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CWeaponCrossbow::SecondaryAttack( void )
+{
+	ToggleZoom();
+	m_flNextSecondaryAttack = gpGlobals->curtime + 1.0;
+}
+
+
+void CWeaponCrossbow::FireBolt( void )
+{
+	if ( m_iClip1 <= 0 )
+	{
+		if ( !m_bFireOnEmpty )
+		{
+			Reload();
+		}
+		else
+		{
+			WeaponSound( EMPTY );
+			m_flNextPrimaryAttack = 0.15;
+		}
+
+		return;
+	}
+
+	CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
+	
+	if ( pOwner == NULL )
+		return;
+
+	Vector vecAiming	= pOwner->GetAutoaimVector( AUTOAIM_2DEGREES );	
+	Vector vecSrc		= pOwner->Weapon_ShootPosition();
+
+	QAngle angAiming;
+	VectorAngles( vecAiming, angAiming );
+
+#ifndef CLIENT_DLL
+	CCrossbowBolt *pBolt = CCrossbowBolt::BoltCreate( vecSrc, angAiming, pOwner );
+
+    // In multiplayer, secondary fire is instantaneous.
+    if ( g_pGameRules->IsMultiplayer() && m_fInZoom )
+    {
+        Vector vecEnd = vecSrc + ( vecAiming * MAX_TRACE_LENGTH );
+        
+        trace_t trace;
+        UTIL_TraceLine( vecSrc, vecEnd, MASK_SHOT, GetOwner(), COLLISION_GROUP_NONE, &trace );
+        pBolt->SetAbsOrigin( trace.endpos );
+
+        // We hit someone
+        if ( trace.m_pEnt && trace.m_pEnt->m_takedamage )
+        {
+            pBolt->SetExplode( false );            
+            pBolt->BoltTouch( trace.m_pEnt );
+            return;
+        }
+    }
+    else
+    {
+        if ( pOwner->GetWaterLevel() == 3 )
+        {
+            pBolt->SetAbsVelocity( vecAiming * BOLT_WATER_VELOCITY );
+        }
+        else
+        {
+            pBolt->SetAbsVelocity( vecAiming * BOLT_AIR_VELOCITY );
+        }
+    }
+
+	pBolt->SetLocalAngularVelocity( QAngle( 0, 0, 10 ) );
+
+    if ( m_fInZoom || !g_pGameRules->IsMultiplayer() )
+    {
+        pBolt->SetExplode( false );
+        
+    }
+#endif
+
+	m_iClip1--;
+
+	pOwner->ViewPunch( QAngle( -2, 0, 0 ) );
+
+	WeaponSound( SINGLE );
+	WeaponSound( RELOAD );
+
+#ifdef CLIENT_DLL
+#else
+	CSoundEnt::InsertSound( SOUND_COMBAT, GetAbsOrigin(), 200, 0.2 );
+#endif
+
+	if ( m_iClip1 > 0 )
+	{
+		SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+	}
+	else if ( pOwner->GetAmmoCount(m_iPrimaryAmmoType) > 0 )
+	{
+		SendWeaponAnim( ACT_VM_SECONDARYATTACK );
+	}
+
+	if ( !m_iClip1 && pOwner->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 )
+	{
+		// HEV suit - indicate out of ammo condition
+		pOwner->SetSuitUpdate("!HEV_AMO0", FALSE, 0);
+	}
+
+	m_flNextPrimaryAttack	= gpGlobals->curtime + 0.75;
+	m_flNextSecondaryAttack	= gpGlobals->curtime + 0.75;
+
+	if ( m_iClip1 > 0 )
+	{
+		SetWeaponIdleTime( gpGlobals->curtime + 5.0 );
+	}
+	else
+	{
+		SetWeaponIdleTime( gpGlobals->curtime + 0.75 );
+	}
+}
+
+
+bool CWeaponCrossbow::Reload( void )
+{
+	bool fRet;
+
+	fRet = DefaultReload( GetMaxClip1(), GetMaxClip2(), ACT_VM_RELOAD );
+	if ( fRet )
+	{
+		if ( m_fInZoom )
+		{
+			ToggleZoom();
+		}
+
+		WeaponSound( RELOAD );
+	}
+
+	return fRet;
+}
+
+
+void CWeaponCrossbow::WeaponIdle( void )
+{
+	CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
+	if ( pPlayer )
+	{
+		pPlayer->GetAutoaimVector( AUTOAIM_2DEGREES );
+	}
+
+	if ( !HasWeaponIdleTimeElapsed() )
+		return;
+
+	int iAnim;
+	float flRand = random->RandomFloat( 0, 1 );
+	if ( flRand <= 0.75 )
+	{
+		if ( m_iClip1 <= 0 )
+			iAnim = ACT_CROSSBOW_IDLE_UNLOADED;
+		else
+			iAnim = ACT_VM_IDLE;
+	}
+	else
+	{
+		if ( m_iClip1 <= 0 )
+			iAnim = ACT_CROSSBOW_FIDGET_UNLOADED;
+		else
+			iAnim = ACT_VM_FIDGET;
+	}
+
+	SendWeaponAnim( iAnim );
+}
+
+
+bool CWeaponCrossbow::Deploy( void )
+{
+	if ( m_iClip1 <= 0 )
+	{
+		return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_CROSSBOW_DRAW_UNLOADED, (char*)GetAnimPrefix() );
+	}
+
+	return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_VM_DRAW, (char*)GetAnimPrefix() );
+}
+
+
+bool CWeaponCrossbow::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+	if ( m_fInZoom )
+	{
+		ToggleZoom();
+	}
+
+	return BaseClass::Holster( pSwitchingTo );
+}
+
+
+void CWeaponCrossbow::ToggleZoom( void )
+{
+	CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
+	if ( !pPlayer )
+	{
+		return;
+	}
+
+#if !defined(CLIENT_DLL)
+	if ( m_fInZoom )
+	{
+		if ( pPlayer->SetFOV( this, 0 ) )
+		{
+			m_fInZoom = false;
+		}
+	}
+	else
+	{
+		if ( pPlayer->SetFOV( this, 20 ) )
+		{
+			m_fInZoom = true;
+		}
+	}
+#endif
+}

game/shared/hl1/hl1mp_weapon_egon.cpp

@@ -0,0 +1,529 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:		Egon
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "npcevent.h"
+#include "hl1mp_basecombatweapon_shared.h"
+#include "Sprite.h"
+#include "beam_shared.h"
+#include "takedamageinfo.h"
+//#include "basecombatcharacter.h"
+//#include "AI_BaseNPC.h"
+
+#ifdef CLIENT_DLL
+#include "c_baseplayer.h"
+#include "hl1/hl1_c_player.h"
+#else
+#include "player.h"
+#include "hl1_player.h"
+#endif
+
+//#include "player.h"
+#include "gamerules.h"
+#include "in_buttons.h"
+
+#ifdef CLIENT_DLL
+#else
+#include "soundent.h"
+#include "game.h"
+#endif
+
+
+#include "vstdlib/random.h"
+#include "engine/IEngineSound.h"
+#include "IEffects.h"
+#ifdef CLIENT_DLL
+#include "c_te_effect_dispatch.h"
+#else
+#include "te_effect_dispatch.h"
+#endif
+
+
+enum EGON_FIRESTATE { FIRE_OFF, FIRE_STARTUP, FIRE_CHARGE };
+
+#define EGON_PULSE_INTERVAL			0.1
+#define EGON_DISCHARGE_INTERVAL		0.1
+
+#define EGON_BEAM_SPRITE		"sprites/xbeam1.vmt"
+#define EGON_FLARE_SPRITE		"sprites/XSpark1.vmt"
+
+extern ConVar sk_plr_dmg_egon_wide;
+
+//-----------------------------------------------------------------------------
+// CWeaponEgon
+//-----------------------------------------------------------------------------
+
+#ifdef CLIENT_DLL
+#define CWeaponEgon C_WeaponEgon
+#endif
+
+class CWeaponEgon : public CBaseHL1MPCombatWeapon
+{
+	DECLARE_CLASS( CWeaponEgon, CBaseHL1MPCombatWeapon );
+public:
+
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+
+    CWeaponEgon(void);
+
+	virtual bool	Deploy( void );
+	void	PrimaryAttack( void );
+    virtual void    Precache( void );
+    
+	void	SecondaryAttack( void )
+	{
+		PrimaryAttack();
+	}
+
+	void	WeaponIdle( void );
+	bool	Holster( CBaseCombatWeapon *pSwitchingTo = NULL );
+
+    //	DECLARE_SERVERCLASS();
+    //	DECLARE_DATADESC();
+
+private:
+	bool	HasAmmo( void );
+	void	UseAmmo( int count );
+	void	Attack( void );
+	void	EndAttack( void );
+	void	Fire( const Vector &vecOrigSrc, const Vector &vecDir );
+	void	UpdateEffect( const Vector &startPoint, const Vector &endPoint );
+	void	CreateEffect( void );
+	void	DestroyEffect( void );
+
+	EGON_FIRESTATE		m_fireState;
+	float				m_flAmmoUseTime;	// since we use < 1 point of ammo per update, we subtract ammo on a timer.
+	float				m_flShakeTime;
+	float				m_flStartFireTime;
+	float				m_flDmgTime;
+	CHandle<CSprite>	m_hSprite;
+	CHandle<CBeam>		m_hBeam;
+	CHandle<CBeam>		m_hNoise;
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponEgon, DT_WeaponEgon );
+
+BEGIN_NETWORK_TABLE( CWeaponEgon, DT_WeaponEgon )
+END_NETWORK_TABLE()    
+
+BEGIN_PREDICTION_DATA( CWeaponEgon )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_egon, CWeaponEgon );
+PRECACHE_WEAPON_REGISTER( weapon_egon );
+
+/*
+IMPLEMENT_SERVERCLASS_ST( CWeaponEgon, DT_WeaponEgon )
+END_SEND_TABLE()
+*/
+
+    /*
+BEGIN_DATADESC( CWeaponEgon )
+	DEFINE_FIELD( m_fireState, FIELD_INTEGER ),
+	DEFINE_FIELD( m_flAmmoUseTime, FIELD_TIME ),
+	DEFINE_FIELD( m_flShakeTime, FIELD_TIME ),
+	DEFINE_FIELD( m_flStartFireTime, FIELD_TIME ),
+	DEFINE_FIELD( m_flDmgTime, FIELD_TIME ),
+	DEFINE_FIELD( m_hSprite, FIELD_EHANDLE ),
+	DEFINE_FIELD( m_hBeam, FIELD_EHANDLE ),
+	DEFINE_FIELD( m_hNoise, FIELD_EHANDLE ),
+END_DATADESC()
+    */
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CWeaponEgon::CWeaponEgon( void )
+{
+	m_bReloadsSingly	= false;
+	m_bFiresUnderwater	= true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponEgon::Precache( void )
+{
+    PrecacheScriptSound( "Weapon_Gluon.Start" );
+    PrecacheScriptSound( "Weapon_Gluon.Run" );
+    PrecacheScriptSound( "Weapon_Gluon.Off" );
+
+	PrecacheModel( EGON_BEAM_SPRITE );
+	PrecacheModel( EGON_FLARE_SPRITE );
+
+	BaseClass::Precache();
+}
+
+bool CWeaponEgon::Deploy( void )
+{
+	m_fireState = FIRE_OFF;
+
+	return BaseClass::Deploy();
+}
+
+bool CWeaponEgon::HasAmmo( void )
+{
+	CHL1_Player *pPlayer = ToHL1Player( GetOwner() );
+	if ( !pPlayer )
+	{
+		return false;
+	}
+
+	if ( pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 )
+		return false;
+
+	return true;
+}
+
+void CWeaponEgon::UseAmmo( int count )
+{
+	CHL1_Player *pPlayer = ToHL1Player( GetOwner() );
+	if ( !pPlayer )
+	{
+		return;
+	}
+
+	if ( pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) >= count )
+		pPlayer->RemoveAmmo( count, m_iPrimaryAmmoType );
+	else
+		pPlayer->RemoveAmmo( pPlayer->GetAmmoCount( m_iPrimaryAmmoType ), m_iPrimaryAmmoType );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CWeaponEgon::PrimaryAttack( void )
+{
+	CHL1_Player *pPlayer = ToHL1Player( GetOwner() );
+	if ( !pPlayer )
+	{
+		return;
+	}
+
+	// don't fire underwater
+	if ( pPlayer->GetWaterLevel() == 3 )
+	{
+		if ( m_fireState != FIRE_OFF || m_hBeam )
+		{
+			EndAttack();
+		}
+		else
+		{
+			WeaponSound( EMPTY );
+		}
+
+		m_flNextPrimaryAttack = gpGlobals->curtime + 0.5;
+		m_flNextSecondaryAttack = gpGlobals->curtime + 0.5;
+		return;
+	}
+
+	Vector vecAiming	= pPlayer->GetAutoaimVector( 0 );
+	Vector vecSrc		= pPlayer->Weapon_ShootPosition( );
+
+	switch( m_fireState )
+	{
+		case FIRE_OFF:
+		{
+			if ( !HasAmmo() )
+			{
+				m_flNextPrimaryAttack = gpGlobals->curtime + 0.25;
+				m_flNextSecondaryAttack = gpGlobals->curtime + 0.25;
+				WeaponSound( EMPTY );
+				return;
+			}
+
+			m_flAmmoUseTime = gpGlobals->curtime;// start using ammo ASAP.
+
+            EmitSound( "Weapon_Gluon.Start" );                
+
+			SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+						
+			m_flShakeTime = 0;
+			m_flStartFireTime = gpGlobals->curtime;
+
+			SetWeaponIdleTime( gpGlobals->curtime + 0.1 );
+
+			m_flDmgTime = gpGlobals->curtime + EGON_PULSE_INTERVAL;
+			m_fireState = FIRE_STARTUP;
+		}
+		break;
+
+		case FIRE_STARTUP:
+		{
+			Fire( vecSrc, vecAiming );
+		
+			if ( gpGlobals->curtime >= ( m_flStartFireTime + 2.0 ) )
+			{
+                EmitSound( "Weapon_Gluon.Run" );
+
+				m_fireState = FIRE_CHARGE;
+			}
+
+			if ( !HasAmmo() )
+			{
+				EndAttack();
+				m_flNextPrimaryAttack = gpGlobals->curtime + 1.0;
+				m_flNextSecondaryAttack = gpGlobals->curtime + 1.0;
+			}
+		}
+		case FIRE_CHARGE:
+		{
+			Fire( vecSrc, vecAiming );
+		
+			if ( !HasAmmo() )
+			{
+				EndAttack();
+				m_flNextPrimaryAttack = gpGlobals->curtime + 1.0;
+				m_flNextSecondaryAttack = gpGlobals->curtime + 1.0;
+			}
+		}
+		break;
+	}
+}
+
+void CWeaponEgon::Fire( const Vector &vecOrigSrc, const Vector &vecDir )
+{
+	CHL1_Player *pPlayer = ToHL1Player( GetOwner() );
+	if ( !pPlayer )
+	{
+		return;
+	}
+
+	//CSoundEnt::InsertSound( SOUND_COMBAT, GetAbsOrigin(), 450, 0.1 );
+    WeaponSound( SINGLE );
+
+	Vector vecDest	= vecOrigSrc + (vecDir * MAX_TRACE_LENGTH);
+
+	trace_t	tr;
+	UTIL_TraceLine( vecOrigSrc, vecDest, MASK_SHOT, pPlayer, COLLISION_GROUP_NONE, &tr );
+
+	if ( tr.allsolid )
+		return;
+
+	CBaseEntity *pEntity = tr.m_pEnt;
+	if ( pEntity == NULL )
+		return;
+
+	if ( g_pGameRules->IsMultiplayer() )
+	{
+		if ( m_hSprite )
+		{
+			if ( pEntity->m_takedamage != DAMAGE_NO )
+			{
+				m_hSprite->TurnOn();
+			}
+			else
+			{
+				m_hSprite->TurnOff();
+			}
+		}
+	}
+
+	if ( m_flDmgTime < gpGlobals->curtime )
+	{
+		// wide mode does damage to the ent, and radius damage
+		if ( pEntity->m_takedamage != DAMAGE_NO )
+		{
+			ClearMultiDamage();
+			CTakeDamageInfo info( this, pPlayer, sk_plr_dmg_egon_wide.GetFloat() * g_pGameRules->GetDamageMultiplier(), DMG_ENERGYBEAM | DMG_ALWAYSGIB );
+			CalculateMeleeDamageForce( &info, vecDir, tr.endpos );
+			pEntity->DispatchTraceAttack( info, vecDir, &tr );
+			ApplyMultiDamage();
+		}
+
+		if ( g_pGameRules->IsMultiplayer() )
+		{
+			// radius damage a little more potent in multiplayer.
+#ifndef CLIENT_DLL
+			RadiusDamage( CTakeDamageInfo( this, pPlayer, sk_plr_dmg_egon_wide.GetFloat() * g_pGameRules->GetDamageMultiplier() / 4, DMG_ENERGYBEAM | DMG_BLAST | DMG_ALWAYSGIB ), tr.endpos, 128, CLASS_NONE, NULL );
+#endif
+		}
+
+		if ( !pPlayer->IsAlive() )
+			return;
+
+		if ( g_pGameRules->IsMultiplayer() )
+		{
+			//multiplayer uses 5 ammo/second
+			if ( gpGlobals->curtime >= m_flAmmoUseTime )
+			{
+				UseAmmo( 1 );
+				m_flAmmoUseTime = gpGlobals->curtime + 0.2;
+			}
+		}
+		else
+		{
+			// Wide mode uses 10 charges per second in single player
+			if ( gpGlobals->curtime >= m_flAmmoUseTime )
+			{
+				UseAmmo( 1 );
+				m_flAmmoUseTime = gpGlobals->curtime + 0.1;
+			}
+		}
+
+		m_flDmgTime = gpGlobals->curtime + EGON_DISCHARGE_INTERVAL;
+		if ( m_flShakeTime < gpGlobals->curtime )
+		{
+#ifndef CLIENT_DLL
+			UTIL_ScreenShake( tr.endpos, 5.0, 150.0, 0.75, 250.0, SHAKE_START );
+#endif
+			m_flShakeTime = gpGlobals->curtime + 1.5;
+		}
+	}
+
+	Vector vecUp, vecRight;
+	QAngle angDir;
+
+	VectorAngles( vecDir, angDir );
+	AngleVectors( angDir, NULL, &vecRight, &vecUp );
+
+	Vector tmpSrc = vecOrigSrc + (vecUp * -8) + (vecRight * 3);
+	UpdateEffect( tmpSrc, tr.endpos );
+}
+
+void CWeaponEgon::UpdateEffect( const Vector &startPoint, const Vector &endPoint )
+{
+	if ( !m_hBeam )
+	{
+		CreateEffect();
+	}
+
+	if ( m_hBeam )
+	{
+		m_hBeam->SetStartPos( endPoint );
+	}
+
+	if ( m_hSprite )
+	{
+		m_hSprite->SetAbsOrigin( endPoint );
+
+		m_hSprite->m_flFrame += 8 * gpGlobals->frametime;
+		if ( m_hSprite->m_flFrame > m_hSprite->Frames() )
+			m_hSprite->m_flFrame = 0;
+	}
+
+	if ( m_hNoise )
+	{
+		m_hNoise->SetStartPos( endPoint );
+	}
+}
+
+void CWeaponEgon::CreateEffect( void )
+{
+#ifndef CLIENT_DLL    
+	CHL1_Player *pPlayer = ToHL1Player( GetOwner() );
+	if ( !pPlayer )
+	{
+		return;
+	}
+
+	DestroyEffect();
+
+	m_hBeam = CBeam::BeamCreate( EGON_BEAM_SPRITE, 3.5 );
+	m_hBeam->PointEntInit( GetAbsOrigin(), this );
+	m_hBeam->SetBeamFlags( FBEAM_SINENOISE );
+	m_hBeam->SetEndAttachment( 1 );
+	m_hBeam->AddSpawnFlags( SF_BEAM_TEMPORARY );	// Flag these to be destroyed on save/restore or level transition
+	m_hBeam->SetOwnerEntity( pPlayer );
+	m_hBeam->SetScrollRate( 10 );
+	m_hBeam->SetBrightness( 200 );
+	m_hBeam->SetColor( 50, 50, 255 );
+	m_hBeam->SetNoise( 0.2 );
+
+	m_hNoise = CBeam::BeamCreate( EGON_BEAM_SPRITE, 5.0 );
+	m_hNoise->PointEntInit( GetAbsOrigin(), this );
+	m_hNoise->SetEndAttachment( 1 );
+	m_hNoise->AddSpawnFlags( SF_BEAM_TEMPORARY );
+	m_hNoise->SetOwnerEntity( pPlayer );
+	m_hNoise->SetScrollRate( 25 );
+	m_hNoise->SetBrightness( 200 );
+	m_hNoise->SetColor( 50, 50, 255 );
+	m_hNoise->SetNoise( 0.8 );
+
+	m_hSprite = CSprite::SpriteCreate( EGON_FLARE_SPRITE, GetAbsOrigin(), false );
+	m_hSprite->SetScale( 1.0 );
+	m_hSprite->SetTransparency( kRenderGlow, 255, 255, 255, 255, kRenderFxNoDissipation );
+	m_hSprite->AddSpawnFlags( SF_SPRITE_TEMPORARY );
+	m_hSprite->SetOwnerEntity( pPlayer );
+#endif    
+}
+
+
+void CWeaponEgon::DestroyEffect( void )
+{
+#ifndef CLIENT_DLL    
+	if ( m_hBeam )
+	{
+		UTIL_Remove( m_hBeam );
+		m_hBeam = NULL;
+	}
+	if ( m_hNoise )
+	{
+		UTIL_Remove( m_hNoise );
+		m_hNoise = NULL;
+	}
+	if ( m_hSprite )
+	{
+		m_hSprite->Expand( 10, 500 );
+		m_hSprite = NULL;
+	}
+#endif
+}
+
+void CWeaponEgon::EndAttack( void )
+{
+    StopSound( "Weapon_Gluon.Run" );
+	
+	if ( m_fireState != FIRE_OFF )
+	{
+        EmitSound( "Weapon_Gluon.Off" );
+	}
+
+	SetWeaponIdleTime( gpGlobals->curtime + 2.0 );
+	m_flNextPrimaryAttack = gpGlobals->curtime + 0.5;
+	m_flNextSecondaryAttack = gpGlobals->curtime + 0.5;
+
+	m_fireState = FIRE_OFF;
+
+	DestroyEffect();
+}
+
+bool CWeaponEgon::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+    EndAttack();
+
+	return BaseClass::Holster( pSwitchingTo );
+}
+
+void CWeaponEgon::WeaponIdle( void )
+{
+	if ( !HasWeaponIdleTimeElapsed() )
+		return;
+
+	if ( m_fireState != FIRE_OFF )
+		 EndAttack();
+	
+	int iAnim;
+
+	float flRand = random->RandomFloat( 0,1 );
+	float flIdleTime;
+	if ( flRand <= 0.5 )
+	{
+		iAnim = ACT_VM_IDLE;
+		flIdleTime = gpGlobals->curtime + random->RandomFloat( 10, 15 );
+	}
+	else 
+	{
+		iAnim = ACT_VM_FIDGET;
+		flIdleTime = gpGlobals->curtime + 3.0;
+	}
+
+	SendWeaponAnim( iAnim );
+
+	SetWeaponIdleTime( flIdleTime );
+}

game/shared/hl1/hl1mp_weapon_gauss.cpp

@@ -0,0 +1,719 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:		Gauss
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "npcevent.h"
+#include "hl1mp_basecombatweapon_shared.h"
+//#include "basecombatcharacter.h"
+//#include "AI_BaseNPC.h"
+#include "takedamageinfo.h"
+#ifdef CLIENT_DLL
+#include "hl1/hl1_c_player.h"
+#else
+#include "hl1_player.h"
+#endif
+#include "gamerules.h"
+#include "in_buttons.h"
+#ifdef CLIENT_DLL
+#else
+#include "soundent.h"
+#include "game.h"
+#endif
+#include "vstdlib/random.h"
+#include "engine/IEngineSound.h"
+#include "soundenvelope.h"
+//#include "hl1_player.h"
+#include "shake.h"
+#include "effect_dispatch_data.h"
+#ifdef CLIENT_DLL
+#include "c_te_effect_dispatch.h"
+#else
+#include "te_effect_dispatch.h"
+#endif
+#include "SoundEmitterSystem/isoundemittersystembase.h"
+
+#define GAUSS_GLOW_SPRITE	"sprites/hotglow.vmt"
+#define GAUSS_BEAM_SPRITE	"sprites/smoke.vmt"
+
+
+extern ConVar sk_plr_dmg_gauss;
+
+#ifdef CLIENT_DLL
+#define CWeaponGauss C_WeaponGauss
+#endif
+
+//-----------------------------------------------------------------------------
+// CWeaponGauss
+//-----------------------------------------------------------------------------
+
+
+class CWeaponGauss : public CBaseHL1MPCombatWeapon
+{
+	DECLARE_CLASS( CWeaponGauss, CBaseHL1MPCombatWeapon );
+public:
+
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+
+	CWeaponGauss( void );
+
+	void	Precache( void );
+	void	PrimaryAttack( void );
+	void	SecondaryAttack( void );
+	void	WeaponIdle( void );
+	void	AddViewKick( void );
+	bool	Deploy( void );
+	bool	Holster( CBaseCombatWeapon *pSwitchingTo = NULL );
+
+//	DECLARE_SERVERCLASS();
+	DECLARE_DATADESC();
+
+private:
+	void	StopSpinSound( void );
+	float	GetFullChargeTime( void );
+	void	StartFire( void );
+	void	Fire( Vector vecOrigSrc, Vector vecDir, float flDamage );
+
+private:
+//	int			m_nAttackState;
+//	bool		m_bPrimaryFire;
+	CNetworkVar( int, m_nAttackState);
+	CNetworkVar( bool, m_bPrimaryFire);
+
+	CSoundPatch	*m_sndCharge;
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponGauss, DT_WeaponGauss );
+
+BEGIN_NETWORK_TABLE( CWeaponGauss, DT_WeaponGauss )
+#ifdef CLIENT_DLL
+	RecvPropInt( RECVINFO( m_nAttackState ) ),
+	RecvPropBool( RECVINFO( m_bPrimaryFire ) ),
+#else
+	SendPropInt( SENDINFO( m_nAttackState ) ),
+	SendPropBool( SENDINFO( m_bPrimaryFire ) ),
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponGauss )
+#ifdef CLIENT_DLL
+	DEFINE_PRED_FIELD( m_nAttackState, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_bPrimaryFire, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+#endif
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_gauss, CWeaponGauss );
+
+PRECACHE_WEAPON_REGISTER( weapon_gauss );
+
+//IMPLEMENT_SERVERCLASS_ST( CWeaponGauss, DT_WeaponGauss )
+//END_SEND_TABLE()
+
+BEGIN_DATADESC( CWeaponGauss )
+	DEFINE_FIELD( m_nAttackState, FIELD_INTEGER ),
+	DEFINE_FIELD( m_bPrimaryFire,	FIELD_BOOLEAN ),
+	DEFINE_SOUNDPATCH( m_sndCharge ),
+END_DATADESC()
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CWeaponGauss::CWeaponGauss( void )
+{
+	m_bReloadsSingly	= false;
+	m_bFiresUnderwater	= false;
+
+	m_bPrimaryFire		= false;
+	m_nAttackState		= 0;
+	m_sndCharge			= NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponGauss::Precache( void )
+{
+	PrecacheModel( GAUSS_GLOW_SPRITE );
+	PrecacheModel( GAUSS_BEAM_SPRITE );
+
+	PrecacheScriptSound( "Weapon_Gauss.Zap1" );
+	PrecacheScriptSound( "Weapon_Gauss.Zap2" );
+	PrecacheScriptSound( "Weapon_Gauss.Fire" );
+	PrecacheScriptSound( "Weapon_Gauss.StaticDischarge" );
+	PrecacheScriptSound( "Weapon_Gauss.Spin" );
+
+	BaseClass::Precache();
+}
+
+float CWeaponGauss::GetFullChargeTime( void )
+{
+	if ( g_pGameRules->IsMultiplayer() )
+	{
+		return 1.5;
+	}
+	else
+	{
+		return 4;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CWeaponGauss::PrimaryAttack( void )
+{
+	CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
+	if ( !pPlayer )
+	{
+		return;
+	}
+
+	if ( pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) < 2 )
+	{
+		WeaponSound( EMPTY );
+		pPlayer->SetNextAttack( gpGlobals->curtime + 0.5 );
+		return;
+	}
+
+//FIXME	pPlayer->m_iWeaponVolume = GAUSS_PRIMARY_FIRE_VOLUME;
+	m_bPrimaryFire = true;
+
+	pPlayer->RemoveAmmo( 2, m_iPrimaryAmmoType );
+
+	StartFire();
+	m_nAttackState = 0;
+	SetWeaponIdleTime( gpGlobals->curtime + 1.0 );
+	pPlayer->SetNextAttack( gpGlobals->curtime + 0.2 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CWeaponGauss::SecondaryAttack( void )
+{
+	CHL1_Player *pPlayer = ToHL1Player( GetOwner() );
+	if ( !pPlayer )
+	{
+		return;
+	}
+
+	// don't fire underwater
+	if ( pPlayer->GetWaterLevel() == 3 )
+	{
+		if ( m_nAttackState != 0 )
+		{
+			EmitSound( "Weapon_Gauss.Zap1" );
+			SendWeaponAnim( ACT_VM_IDLE );
+			m_nAttackState = 0;
+		}
+		else
+		{
+			WeaponSound( EMPTY );
+		}
+
+		m_flNextSecondaryAttack = m_flNextPrimaryAttack = gpGlobals->curtime + 0.5;
+		return;
+	}
+
+	if ( m_nAttackState == 0 )
+	{
+		if ( pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 )
+		{
+			WeaponSound( EMPTY );
+			pPlayer->SetNextAttack( gpGlobals->curtime + 0.5 );
+			return;
+		}
+
+		m_bPrimaryFire = false;
+
+		pPlayer->RemoveAmmo( 1, m_iPrimaryAmmoType );	// take one ammo just to start the spin
+		pPlayer->m_flNextAmmoBurn = gpGlobals->curtime;
+
+		// spin up
+//FIXME		pPlayer->m_iWeaponVolume = GAUSS_PRIMARY_CHARGE_VOLUME;
+		
+		SendWeaponAnim( ACT_GAUSS_SPINUP );
+		m_nAttackState = 1;
+		SetWeaponIdleTime( gpGlobals->curtime + 0.5 );
+		pPlayer->m_flStartCharge = gpGlobals->curtime;
+		pPlayer->m_flAmmoStartCharge = gpGlobals->curtime + GetFullChargeTime();
+
+		//Start looping sound
+		if ( m_sndCharge == NULL )
+		{
+			CPASAttenuationFilter filter( this );
+			m_sndCharge	= (CSoundEnvelopeController::GetController()).SoundCreate( filter, entindex(), CHAN_WEAPON, "Weapon_Gauss.Spin", ATTN_NORM );
+		}
+
+		if ( m_sndCharge != NULL )
+		{
+			(CSoundEnvelopeController::GetController()).Play( m_sndCharge, 1.0f, 110 );
+		}
+	}
+	else if (m_nAttackState == 1)
+	{
+		if ( HasWeaponIdleTimeElapsed() )
+		{
+			SendWeaponAnim( ACT_GAUSS_SPINCYCLE );
+			m_nAttackState = 2;
+		}
+	}
+	else
+	{
+		// during the charging process, eat one bit of ammo every once in a while
+		if ( gpGlobals->curtime >= pPlayer->m_flNextAmmoBurn && pPlayer->m_flNextAmmoBurn != 1000 )
+		{
+			pPlayer->RemoveAmmo( 1, m_iPrimaryAmmoType );
+
+			if ( g_pGameRules->IsMultiplayer() )
+			{
+				pPlayer->m_flNextAmmoBurn = gpGlobals->curtime + 0.1;
+			}
+			else
+			{
+				pPlayer->m_flNextAmmoBurn = gpGlobals->curtime + 0.3;
+			}
+		}
+
+		if ( pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 )
+		{
+			// out of ammo! force the gun to fire
+			StartFire();
+			m_nAttackState = 0;
+			SetWeaponIdleTime( gpGlobals->curtime + 1.0 );
+			pPlayer->SetNextAttack( gpGlobals->curtime + 1 );
+			return;
+		}
+		
+		if ( gpGlobals->curtime >= pPlayer->m_flAmmoStartCharge )
+		{
+			// don't eat any more ammo after gun is fully charged.
+			pPlayer->m_flNextAmmoBurn = 1000;
+		}
+
+		int pitch = ( gpGlobals->curtime - pPlayer->m_flStartCharge ) * ( 150 / GetFullChargeTime() ) + 100;
+		if ( pitch > 250 ) 
+			 pitch = 250;
+		
+		// ALERT( at_console, "%d %d %d\n", m_nAttackState, m_iSoundState, pitch );
+
+//		if ( m_iSoundState == 0 )
+//			ALERT( at_console, "sound state %d\n", m_iSoundState );
+
+		if ( m_sndCharge != NULL )
+		{
+			(CSoundEnvelopeController::GetController()).SoundChangePitch( m_sndCharge, pitch, 0 );
+		}
+
+//FIXME		m_pPlayer->m_iWeaponVolume = GAUSS_PRIMARY_CHARGE_VOLUME;
+		
+		// m_flTimeWeaponIdle = gpGlobals->curtime + 0.1;
+		if ( pPlayer->m_flStartCharge < gpGlobals->curtime - 10 )
+		{
+			// Player charged up too long. Zap him.
+			EmitSound( "Weapon_Gauss.Zap1" );
+			EmitSound( "Weapon_Gauss.Zap2" );
+			
+			m_nAttackState = 0;
+			SetWeaponIdleTime( gpGlobals->curtime + 1.0 );
+			pPlayer->SetNextAttack( gpGlobals->curtime + 1.0 );
+				
+#if !defined(CLIENT_DLL )
+			// Add DMG_CRUSH because we don't want any physics force
+			pPlayer->TakeDamage( CTakeDamageInfo( this, this, 50, DMG_SHOCK | DMG_CRUSH ) );
+
+			color32 gaussDamage = {255,128,0,128};
+			UTIL_ScreenFade( pPlayer, gaussDamage, 2, 0.5, FFADE_IN );
+#endif
+
+			SendWeaponAnim( ACT_VM_IDLE );
+			
+			StopSpinSound();
+			// Player may have been killed and this weapon dropped, don't execute any more code after this!
+			return;
+		}
+	}
+}
+
+//=========================================================
+// StartFire- since all of this code has to run and then 
+// call Fire(), it was easier at this point to rip it out 
+// of weaponidle() and make its own function then to try to
+// merge this into Fire(), which has some identical variable names 
+//=========================================================
+void CWeaponGauss::StartFire( void )
+{
+	float flDamage;
+	
+	CHL1_Player *pPlayer = ToHL1Player( GetOwner() );
+	if ( !pPlayer )
+	{
+		return;
+	}
+
+	Vector vecAiming	= pPlayer->GetAutoaimVector( 0 );
+	Vector vecSrc		= pPlayer->Weapon_ShootPosition( );
+
+	if ( gpGlobals->curtime - pPlayer->m_flStartCharge > GetFullChargeTime() )
+	{
+		flDamage = 200;
+	}
+	else
+	{
+		flDamage = 200 * (( gpGlobals->curtime - pPlayer->m_flStartCharge) / GetFullChargeTime() );
+	}
+
+	if ( m_bPrimaryFire )
+	{
+		flDamage = sk_plr_dmg_gauss.GetFloat() * g_pGameRules->GetDamageMultiplier();
+	}
+
+	//ALERT ( at_console, "Time:%f Damage:%f\n", gpGlobals->curtime - m_pPlayer->m_flStartCharge, flDamage );
+	Vector	vecNewVel	= pPlayer->GetAbsVelocity();
+	float	flZVel		= vecNewVel.z;
+
+	if ( !m_bPrimaryFire )
+	{
+		vecNewVel = vecNewVel - vecAiming * flDamage * 5;
+		pPlayer->SetAbsVelocity( vecNewVel );
+	}
+
+	if ( !g_pGameRules->IsMultiplayer() )
+	{
+		// in deathmatch, gauss can pop you up into the air. Not in single play.
+		vecNewVel.z = flZVel;
+		pPlayer->SetAbsVelocity( vecNewVel );
+	}
+
+	// player "shoot" animation
+	pPlayer->SetAnimation( PLAYER_ATTACK1 );
+
+	// time until aftershock 'static discharge' sound
+	pPlayer->m_flPlayAftershock = gpGlobals->curtime + random->RandomFloat( 0.3, 0.8 );
+
+	Fire( vecSrc, vecAiming, flDamage );
+}
+
+void CWeaponGauss::Fire( Vector vecOrigSrc, Vector vecDir, float flDamage )
+{
+	CBaseEntity *pIgnore;
+	Vector		vecSrc		= vecOrigSrc;
+	Vector		vecDest		= vecSrc + vecDir * MAX_TRACE_LENGTH;
+	bool		fFirstBeam	= true;
+	bool		fHasPunched = false;
+	float		flMaxFrac	= 1.0;
+	int			nMaxHits	= 10;
+
+	CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
+	if ( !pPlayer )
+	{
+		return;
+	}
+
+//FIXME	pPlayer->m_iWeaponVolume = GAUSS_PRIMARY_FIRE_VOLUME;
+
+	StopSpinSound();
+	
+	pIgnore = pPlayer;
+
+//	ALERT( at_console, "%f %f\n", tr.flFraction, flMaxFrac );
+
+	while ( flDamage > 10 && nMaxHits > 0 )
+	{
+		trace_t	tr;
+
+		nMaxHits--;
+
+		// ALERT( at_console, "." );
+		UTIL_TraceLine( vecSrc, vecDest, MASK_SHOT, pIgnore, COLLISION_GROUP_NONE, &tr );
+
+		if ( tr.allsolid )
+			break;
+
+		CBaseEntity *pEntity = tr.m_pEnt;
+		if (pEntity == NULL)
+			break;
+
+		CBroadcastRecipientFilter filter;
+		CEffectData	data6;
+		if ( fFirstBeam )
+		{
+			pPlayer->DoMuzzleFlash();
+			fFirstBeam = false;
+	
+			data6.m_vOrigin		= tr.endpos;
+//			data6.m_nEntIndex	= pPlayer->GetViewModel()->entindex();
+#ifdef CLIENT_DLL
+			data6.m_hEntity	= pPlayer;
+#else
+			data6.m_nEntIndex	= pPlayer->entindex();
+#endif
+			data6.m_fFlags		= m_bPrimaryFire;
+			te->DispatchEffect( filter, 0.0, data6.m_vOrigin, "HL1GaussBeam", data6 );
+		}
+		else
+		{
+			data6.m_vOrigin		= tr.endpos;
+			data6.m_vStart		= vecSrc;
+			data6.m_fFlags		= m_bPrimaryFire;
+			te->DispatchEffect( filter, 0.0, data6.m_vOrigin, "HL1GaussBeamReflect", data6 );
+		}
+		
+		bool fShouldDamageEntity = ( pEntity->m_takedamage != DAMAGE_NO );
+
+		if ( fShouldDamageEntity )
+		{
+			ClearMultiDamage();
+			CTakeDamageInfo info( this, pPlayer, flDamage, DMG_ENERGYBEAM );
+			CalculateMeleeDamageForce( &info, vecDir, tr.endpos );
+			pEntity->DispatchTraceAttack( info, vecDir, &tr );
+			ApplyMultiDamage();
+		}
+
+		if ( pEntity->IsBSPModel() && !fShouldDamageEntity )
+		{
+			float n;
+
+			pIgnore = NULL;
+
+			n = -DotProduct( tr.plane.normal, vecDir );
+
+			if ( n < 0.5 ) // 60 degrees
+			{
+				// ALERT( at_console, "reflect %f\n", n );
+				// reflect
+				Vector vecReflect;
+			
+				vecReflect = 2.0 * tr.plane.normal * n + vecDir;
+				flMaxFrac = flMaxFrac - tr.fraction;
+				vecDir = vecReflect;
+				vecSrc = tr.endpos;// + vecDir * 8;
+				vecDest = vecSrc + vecDir * MAX_TRACE_LENGTH;
+
+#if !defined(CLIENT_DLL)
+				// explode a bit
+				RadiusDamage( CTakeDamageInfo( this, pPlayer, flDamage * n, DMG_BLAST ), tr.endpos, flDamage * n * 2.5, CLASS_NONE, NULL );
+#endif
+
+				CEffectData	data1;
+				data1.m_vOrigin		= tr.endpos;
+				data1.m_vNormal		= tr.plane.normal;
+				data1.m_flMagnitude	= flDamage * n;
+				DispatchEffect( "HL1GaussReflect", data1 );
+
+				// lose energy
+				if (n == 0)
+					n = 0.1;
+
+				flDamage = flDamage * (1 - n);
+			}
+			else
+			{
+				// tunnel
+				UTIL_ImpactTrace( &tr, DMG_ENERGYBEAM );
+
+				CEffectData	data4;
+				data4.m_vOrigin		= tr.endpos;
+				data4.m_flMagnitude	= flDamage;
+				DispatchEffect( "HL1GaussWallImpact1", data4 );
+
+				// limit it to one hole punch
+				if ( fHasPunched )
+					break;
+
+				fHasPunched = true;
+
+				// try punching through wall if secondary attack (primary is incapable of breaking through)
+				if ( !m_bPrimaryFire )
+				{
+					trace_t punch_tr;
+
+					UTIL_TraceLine( tr.endpos + vecDir * 8, vecDest, MASK_SHOT, pIgnore, COLLISION_GROUP_NONE, &punch_tr);
+					if ( !punch_tr.allsolid )
+					{
+						trace_t exit_tr;
+						// trace backwards to find exit point
+						UTIL_TraceLine( punch_tr.endpos, tr.endpos, MASK_SHOT, pIgnore, COLLISION_GROUP_NONE, &exit_tr);
+
+						float n = (exit_tr.endpos - tr.endpos).Length( );
+
+						if ( n < flDamage )
+						{
+							if (n == 0)
+								n = 1;
+
+							flDamage -= n;
+
+							CEffectData	data2;
+							data2.m_vOrigin		= tr.endpos;
+							data2.m_vNormal		= vecDir;
+							DispatchEffect( "HL1GaussWallPunchEnter", data2 );
+
+							UTIL_ImpactTrace( &exit_tr, DMG_ENERGYBEAM );
+
+							CEffectData	data3;
+							data3.m_vOrigin		= exit_tr.endpos;
+							data3.m_vNormal		= vecDir;
+							data3.m_flMagnitude	= flDamage;
+							DispatchEffect( "HL1GaussWallPunchExit", data3 );
+
+							// ALERT( at_console, "punch %f\n", n );
+
+							// exit blast damage
+							float flDamageRadius;
+
+							if ( g_pGameRules->IsMultiplayer() )
+							{
+								flDamageRadius = flDamage * 1.75;  // Old code == 2.5
+							}
+							else
+							{
+								flDamageRadius = flDamage * 2.5;
+							}
+
+#if !defined( CLIENT_DLL)
+							RadiusDamage( CTakeDamageInfo( this, pPlayer, flDamage, DMG_BLAST ), exit_tr.endpos + vecDir * 8, flDamageRadius, CLASS_NONE, NULL );
+
+							CSoundEnt::InsertSound( SOUND_COMBAT, GetAbsOrigin(), 1024, 3.0 );
+#endif
+
+							vecSrc = exit_tr.endpos + vecDir;
+						}
+					}
+					else
+					{
+						 //ALERT( at_console, "blocked %f\n", n );
+						flDamage = 0;
+					}
+				}
+				else
+				{
+					//ALERT( at_console, "blocked solid\n" );
+					if ( m_bPrimaryFire )
+					{
+						// slug doesn't punch through ever with primary 
+						// fire, so leave a little glowy bit and make some balls
+						CEffectData	data5;
+						data5.m_vOrigin		= tr.endpos;
+						data5.m_vNormal		= tr.plane.normal;
+						DispatchEffect( "HL1GaussWallImpact2", data5 );
+#if !defined( CLIENT_DLL)
+						CSoundEnt::InsertSound( SOUND_COMBAT, GetAbsOrigin(), 600, 0.5 );
+#endif
+					}
+					
+					flDamage = 0;
+				}
+
+			}
+		}
+		else
+		{
+			vecSrc = tr.endpos + vecDir;
+			pIgnore = pEntity;
+		}
+	}
+
+	pPlayer->ViewPunch( QAngle( -2, 0, 0 ) );
+	SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+
+	CPASAttenuationFilter filter( this );
+
+	CSoundParameters params;
+	if ( GetParametersForSound( "Weapon_Gauss.Fire", params, NULL ) )
+	{
+		EmitSound_t ep( params );
+		ep.m_flVolume = 0.5 + flDamage * (1.0 / 400.0);
+		EmitSound( filter, entindex(), ep );
+	}
+}
+
+void CWeaponGauss::WeaponIdle( void )
+{
+	CHL1_Player *pPlayer = ToHL1Player( GetOwner() );
+	if ( !pPlayer )
+	{
+		return;
+	}
+
+	// play aftershock static discharge
+	if ( pPlayer->m_flPlayAftershock && pPlayer->m_flPlayAftershock < gpGlobals->curtime )
+	{
+		EmitSound( "Weapon_Gauss.StaticDischarge" );
+		pPlayer->m_flPlayAftershock = 0.0;
+	}
+
+	if ( !HasWeaponIdleTimeElapsed() )
+		return;
+
+	if ( m_nAttackState != 0 )
+	{
+		StartFire();
+		m_nAttackState = 0;
+		SetWeaponIdleTime( gpGlobals->curtime + 2.0 );
+	}
+	else
+	{
+		float flRand = random->RandomFloat( 0, 1 );
+		if ( flRand <= 0.75 )
+		{
+			SendWeaponAnim( ACT_VM_IDLE );
+			SetWeaponIdleTime( gpGlobals->curtime + random->RandomFloat( 10, 15 ) );
+		}
+		else
+		{
+			SendWeaponAnim( ACT_VM_FIDGET );
+			SetWeaponIdleTime( gpGlobals->curtime + 3 );
+		}
+	}
+}
+
+/*
+==================================================
+AddViewKick
+==================================================
+*/
+
+void CWeaponGauss::AddViewKick( void )
+{
+}
+
+bool CWeaponGauss::Deploy( void )
+{
+	if ( DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_VM_DRAW, (char*)GetAnimPrefix() ) )
+	{
+		CHL1_Player *pPlayer = ToHL1Player( GetOwner() );
+		if ( pPlayer )
+		{
+			pPlayer->m_flPlayAftershock = 0.0;
+		}
+
+		return true;
+	}
+	else
+	{
+		return false;
+	}
+}
+
+bool CWeaponGauss::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+
+	StopSpinSound();
+	m_nAttackState = 0;
+
+	return BaseClass::Holster(pSwitchingTo);
+}
+
+void CWeaponGauss::StopSpinSound( void )
+{
+	if ( m_sndCharge != NULL )
+	{
+		(CSoundEnvelopeController::GetController()).SoundDestroy( m_sndCharge );
+		m_sndCharge = NULL;
+	}
+}

game/shared/hl1/hl1mp_weapon_glock.cpp

@@ -0,0 +1,205 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:		Glock - hand gun
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "npcevent.h"
+#include "hl1mp_basecombatweapon_shared.h"
+//#include "basecombatcharacter.h"
+//#include "AI_BaseNPC.h"
+#ifdef CLIENT_DLL
+#include "c_baseplayer.h"
+#else
+#include "player.h"
+#endif
+#include "gamerules.h"
+#include "in_buttons.h"
+#ifdef CLIENT_DLL
+#else
+#include "soundent.h"
+#include "game.h"
+#endif
+#include "vstdlib/random.h"
+#include "engine/IEngineSound.h"
+
+#ifdef CLIENT_DLL
+#define CWeaponGlock C_WeaponGlock
+#endif
+
+class CWeaponGlock : public CBaseHL1MPCombatWeapon
+{
+	DECLARE_CLASS( CWeaponGlock, CBaseHL1MPCombatWeapon );
+
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+
+public:
+
+	CWeaponGlock(void);
+
+	void	Precache( void );
+	void	PrimaryAttack( void );
+	void	SecondaryAttack( void );
+	bool	Reload( void );
+	void	WeaponIdle( void );
+	void	DryFire( void );
+
+private:
+	void	GlockFire( float flSpread , float flCycleTime, bool fUseAutoAim );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponGlock, DT_WeaponGlock );
+
+BEGIN_NETWORK_TABLE( CWeaponGlock, DT_WeaponGlock )
+END_NETWORK_TABLE()
+
+LINK_ENTITY_TO_CLASS( weapon_glock, CWeaponGlock );
+
+BEGIN_PREDICTION_DATA( CWeaponGlock )
+END_PREDICTION_DATA()
+
+PRECACHE_WEAPON_REGISTER( weapon_glock );
+
+
+CWeaponGlock::CWeaponGlock( void )
+{
+	m_bReloadsSingly	= false;
+	m_bFiresUnderwater	= true;
+}
+
+
+void CWeaponGlock::Precache( void )
+{
+
+	BaseClass::Precache();
+}
+
+
+void CWeaponGlock::DryFire( void )
+{
+	WeaponSound( EMPTY );
+	SendWeaponAnim( ACT_VM_DRYFIRE );
+		
+	m_flNextPrimaryAttack = gpGlobals->curtime + 0.2;
+}
+
+
+void CWeaponGlock::PrimaryAttack( void )
+{
+	GlockFire( 0.01, 0.3, TRUE );
+}
+
+
+void CWeaponGlock::SecondaryAttack( void )
+{
+	GlockFire( 0.1, 0.2, FALSE );
+}
+
+
+void CWeaponGlock::GlockFire( float flSpread , float flCycleTime, bool fUseAutoAim )
+{
+	// Only the player fires this way so we can cast
+	CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
+
+	if ( !pPlayer )
+	{
+		return;
+	}
+
+	if ( m_iClip1 <= 0 )
+	{
+		if ( !m_bFireOnEmpty )
+		{
+			Reload();
+		}
+		else
+		{
+			DryFire();
+		}
+
+		return;
+	}
+
+	WeaponSound( SINGLE );
+
+	pPlayer->DoMuzzleFlash();
+
+	m_iClip1--;
+
+	if ( m_iClip1 == 0 )
+		SendWeaponAnim( ACT_GLOCK_SHOOTEMPTY );
+	else
+		SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+
+	pPlayer->SetAnimation( PLAYER_ATTACK1 );
+
+	m_flNextPrimaryAttack	= gpGlobals->curtime + flCycleTime;
+	m_flNextSecondaryAttack	= gpGlobals->curtime + flCycleTime;
+
+	Vector vecSrc = pPlayer->Weapon_ShootPosition();
+	Vector vecAiming;
+	
+	if ( fUseAutoAim )
+	{
+		vecAiming = pPlayer->GetAutoaimVector( AUTOAIM_10DEGREES );	
+	}
+	else
+	{
+		vecAiming = pPlayer->GetAutoaimVector( 0 );	
+	}
+
+//	pPlayer->FireBullets( 1, vecSrc, vecAiming, Vector( flSpread, flSpread, flSpread ), MAX_TRACE_LENGTH, m_iPrimaryAmmoType, 0 );
+	FireBulletsInfo_t info( 1, vecSrc, vecAiming, Vector( flSpread, flSpread, flSpread ), MAX_TRACE_LENGTH, m_iPrimaryAmmoType );
+	info.m_pAttacker = pPlayer;
+	pPlayer->FireBullets( info );
+
+	EjectShell( pPlayer, 0 );
+
+	pPlayer->ViewPunch( QAngle( -2, 0, 0 ) );
+#if !defined(CLIENT_DLL)
+	pPlayer->SetMuzzleFlashTime( gpGlobals->curtime + 0.5 );
+
+	CSoundEnt::InsertSound( SOUND_COMBAT, GetAbsOrigin(), 400, 0.2 );
+#endif
+
+	if ( !m_iClip1 && pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 )
+	{
+		// HEV suit - indicate out of ammo condition
+		pPlayer->SetSuitUpdate("!HEV_AMO0", FALSE, 0);
+	}
+
+	SetWeaponIdleTime( gpGlobals->curtime + random->RandomFloat( 10, 15 ) );
+}
+
+
+bool CWeaponGlock::Reload( void )
+{
+	bool iResult;
+
+	if ( m_iClip1 == 0 )
+		iResult = DefaultReload( GetMaxClip1(), GetMaxClip2(), ACT_GLOCK_SHOOT_RELOAD );
+	else
+		iResult = DefaultReload( GetMaxClip1(), GetMaxClip2(), ACT_VM_RELOAD );
+
+	return iResult;
+}
+
+
+
+void CWeaponGlock::WeaponIdle( void )
+{
+	CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
+	if ( pPlayer )
+	{
+		pPlayer->GetAutoaimVector( AUTOAIM_10DEGREES );
+	}
+
+	// only idle if the slid isn't back
+	if ( m_iClip1 != 0 )
+	{
+		BaseClass::WeaponIdle();
+	}
+}

game/shared/hl1/hl1mp_weapon_handgrenade.cpp

@@ -0,0 +1,456 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:		Hand grenade
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "npcevent.h"
+#include "hl1mp_basecombatweapon_shared.h"
+//#include "basecombatcharacter.h"
+//#include "AI_BaseNPC.h"
+#ifdef CLIENT_DLL
+#include "hl1/hl1_c_player.h"
+#else
+#include "hl1_player.h"
+#endif
+#include "gamerules.h"
+#include "in_buttons.h"
+#ifdef CLIENT_DLL
+#else
+#include "soundent.h"
+#include "game.h"
+#endif
+#include "vstdlib/random.h"
+#include "engine/IEngineSound.h"
+#ifdef CLIENT_DLL
+#else
+#include "hl1_basegrenade.h"
+#endif
+
+
+#define HANDGRENADE_MODEL "models/w_grenade.mdl"
+
+
+#ifndef CLIENT_DLL
+
+extern ConVar sk_plr_dmg_grenade;
+
+//-----------------------------------------------------------------------------
+// CHandGrenade
+//-----------------------------------------------------------------------------
+LINK_ENTITY_TO_CLASS( grenade_hand, CHandGrenade );
+
+BEGIN_DATADESC( CHandGrenade )
+	DEFINE_ENTITYFUNC( BounceTouch ),
+END_DATADESC()
+
+
+void CHandGrenade::Spawn( void )
+{
+	SetMoveType( MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_BOUNCE );
+	SetSolid( SOLID_BBOX );
+	AddSolidFlags( FSOLID_NOT_STANDABLE );
+
+	SetModel( HANDGRENADE_MODEL ); 
+
+	UTIL_SetSize( this, Vector( 0, 0, 0 ), Vector( 0, 0, 0 ) );
+
+	m_bHasWarnedAI = false;
+}
+
+
+void CHandGrenade::Precache( void )
+{
+	BaseClass::Precache( );
+
+	PrecacheScriptSound( "Weapon_HandGrenade.GrenadeBounce" );
+
+	PrecacheModel( HANDGRENADE_MODEL );
+}
+
+
+void CHandGrenade::ShootTimed( CBaseCombatCharacter *pOwner, Vector vecVelocity, float flTime )
+{
+	SetAbsVelocity( vecVelocity );
+
+	SetThrower( pOwner );
+	SetOwnerEntity( pOwner );
+
+	SetTouch( &CHandGrenade::BounceTouch );	// Bounce if touched
+
+	m_flDetonateTime = gpGlobals->curtime + flTime;
+	SetThink( &CBaseGrenade::TumbleThink );
+	SetNextThink( gpGlobals->curtime + 0.1 );
+	if ( flTime < 0.1 )
+	{
+		SetNextThink( gpGlobals->curtime );
+		SetAbsVelocity( vec3_origin );
+	}
+
+//	SetSequence( SelectWeightedSequence( ACT_GRENADE_TOSS ) );
+	SetSequence( 0 );
+	m_flPlaybackRate = 1.0;
+
+	SetAbsAngles( QAngle( 0,0,60) );
+
+	AngularImpulse angImpulse;
+	angImpulse[0] = random->RandomInt( -200, 200 );
+	angImpulse[1] = random->RandomInt( 400, 500 );
+	angImpulse[2] = random->RandomInt( -100, 100 );
+	ApplyLocalAngularVelocityImpulse( angImpulse );	
+
+	SetGravity( UTIL_ScaleForGravity( 400 ) );	// use a lower gravity for grenades to make them easier to see
+	SetFriction( 0.8 );
+
+	SetDamage( sk_plr_dmg_grenade.GetFloat() );
+	SetDamageRadius( GetDamage() * 2.5 );
+}
+
+
+void CHandGrenade ::BounceSound( void )
+{
+	EmitSound( "Weapon_HandGrenade.GrenadeBounce" );
+}
+
+
+void CHandGrenade::BounceTouch( CBaseEntity *pOther )
+{
+	if ( pOther->IsSolidFlagSet(FSOLID_TRIGGER | FSOLID_VOLUME_CONTENTS) )
+		return;
+
+	// don't hit the guy that launched this grenade
+	if ( pOther == GetThrower() )
+		return;
+
+	// Do a special test for players
+	if ( pOther->IsPlayer() )
+	{
+		// Never hit a player again (we'll explode and fixup anyway)
+		SetCollisionGroup( COLLISION_GROUP_DEBRIS );
+	}
+	// only do damage if we're moving fairly fast
+	if ( (pOther->m_takedamage != DAMAGE_NO) && (m_flNextAttack < gpGlobals->curtime && GetAbsVelocity().Length() > 100))
+	{
+		if ( GetThrower() )
+		{
+			trace_t tr;
+			tr = CBaseEntity::GetTouchTrace( );
+			ClearMultiDamage( );
+			Vector forward;
+			AngleVectors( GetAbsAngles(), &forward );
+
+			CTakeDamageInfo info( this, GetThrower(), 1, DMG_CLUB );
+			CalculateMeleeDamageForce( &info, forward, tr.endpos );
+			pOther->DispatchTraceAttack( info, forward, &tr ); 
+			ApplyMultiDamage();
+		}
+		m_flNextAttack = gpGlobals->curtime + 1.0; // debounce
+	}
+
+	Vector vecTestVelocity;
+	// m_vecAngVelocity = Vector (300, 300, 300);
+
+	// this is my heuristic for modulating the grenade velocity because grenades dropped purely vertical
+	// or thrown very far tend to slow down too quickly for me to always catch just by testing velocity. 
+	// trimming the Z velocity a bit seems to help quite a bit.
+	vecTestVelocity = GetAbsVelocity(); 
+	vecTestVelocity.z *= 0.45;
+
+	if ( !m_bHasWarnedAI && vecTestVelocity.Length() <= 60 )
+	{
+		// grenade is moving really slow. It's probably very close to where it will ultimately stop moving. 
+		// emit the danger sound.
+		
+		// register a radius louder than the explosion, so we make sure everyone gets out of the way
+		CSoundEnt::InsertSound ( SOUND_DANGER, GetAbsOrigin(), m_flDamage / 0.4, 0.3 );
+		m_bHasWarnedAI = TRUE;
+	}
+
+	// HACKHACK - On ground isn't always set, so look for ground underneath
+	trace_t tr;
+	UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() - Vector(0,0,10), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );
+
+	if ( tr.fraction < 1.0 )
+	{
+		// add a bit of static friction
+//		SetAbsVelocity( GetAbsVelocity() * 0.8 );
+		SetSequence( SelectWeightedSequence( ACT_IDLE ) );
+		SetAbsAngles( vec3_angle );
+	}
+
+	// play bounce sound
+	BounceSound();
+
+	m_flPlaybackRate = GetAbsVelocity().Length() / 200.0;
+	if (m_flPlaybackRate > 1.0)
+		m_flPlaybackRate = 1;
+	else if (m_flPlaybackRate < 0.5)
+		m_flPlaybackRate = 0;
+}
+
+#endif
+
+#ifdef CLIENT_DLL
+#define CWeaponHandGrenade C_WeaponHandGrenade
+#endif
+
+//-----------------------------------------------------------------------------
+// CWeaponHandGrenade
+//-----------------------------------------------------------------------------
+
+class CWeaponHandGrenade : public CBaseHL1MPCombatWeapon
+{
+	DECLARE_CLASS( CWeaponHandGrenade, CBaseHL1MPCombatWeapon );
+public:
+
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+
+	CWeaponHandGrenade( void );
+
+	void	Precache( void );
+	void	PrimaryAttack( void );
+	void	WeaponIdle( void );
+	bool	Deploy( void );
+	bool	Holster( CBaseCombatWeapon *pSwitchingTo = NULL );
+
+//	DECLARE_SERVERCLASS();
+	DECLARE_DATADESC();
+
+private:
+//	float m_flStartThrow;
+//	float m_flReleaseThrow;
+	CNetworkVar( float, m_flStartThrow );
+	CNetworkVar( float, m_flReleaseThrow );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponHandGrenade, DT_WeaponHandGrenade );
+
+BEGIN_NETWORK_TABLE( CWeaponHandGrenade, DT_WeaponHandGrenade )
+#ifdef CLIENT_DLL
+	RecvPropFloat( RECVINFO( m_flStartThrow ) ),
+	RecvPropFloat( RECVINFO( m_flReleaseThrow ) ),
+#else
+	SendPropFloat( SENDINFO( m_flStartThrow ) ),
+	SendPropFloat( SENDINFO( m_flReleaseThrow ) ),
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponHandGrenade )
+#ifdef CLIENT_DLL
+	DEFINE_PRED_FIELD( m_flStartThrow, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_flReleaseThrow, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+#endif
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_handgrenade, CWeaponHandGrenade );
+
+PRECACHE_WEAPON_REGISTER( weapon_handgrenade );
+
+//IMPLEMENT_SERVERCLASS_ST( CWeaponHandGrenade, DT_WeaponHandGrenade )
+//END_SEND_TABLE()
+
+BEGIN_DATADESC( CWeaponHandGrenade )
+END_DATADESC()
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CWeaponHandGrenade::CWeaponHandGrenade( void )
+{
+	m_bReloadsSingly	= false;
+	m_bFiresUnderwater	= true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponHandGrenade::Precache( void )
+{
+#ifndef CLIENT_DLL
+	UTIL_PrecacheOther( "grenade_hand" );
+#endif
+
+	BaseClass::Precache();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CWeaponHandGrenade::PrimaryAttack( void )
+{
+	CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
+	if ( !pPlayer )
+	{
+		return;
+	}
+
+	if ( ( m_flStartThrow <= 0 ) && pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) > 0 )
+	{
+		m_flStartThrow		= gpGlobals->curtime;
+		m_flReleaseThrow	= 0;
+
+		SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+		SetWeaponIdleTime( gpGlobals->curtime + 0.5 );
+	}
+}
+
+
+void CWeaponHandGrenade::WeaponIdle( void )
+{
+	if ( m_flReleaseThrow == 0 && m_flStartThrow )
+		 m_flReleaseThrow = gpGlobals->curtime;
+
+	if ( !HasWeaponIdleTimeElapsed() )
+		return;
+
+	CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
+	if ( !pPlayer )
+	{
+		return;
+	}
+
+	if ( m_flStartThrow )
+	{
+		Vector vecAiming = pPlayer->GetAutoaimVector( 0 );
+
+		QAngle angThrow;
+		VectorAngles( vecAiming, angThrow );
+
+		Vector vecUp;
+		Vector vecRight;
+		AngleVectors( angThrow, NULL, &vecRight, &vecUp );
+
+		if ( angThrow.x > 180 )	// player is pitching up
+			angThrow.x = -15 - ( 360 - angThrow.x ) * ( ( 90 - 10 ) / 90.0 );
+		else					// player is pitching down
+			angThrow.x = -15 + angThrow.x * ( ( 90 + 10 ) / 90.0 );
+
+		float flVel = ( 90 - angThrow.x ) * 4;
+		if ( flVel > 500 )
+			flVel = 500;
+
+		Vector vecFwd;
+		AngleVectors( angThrow, &vecFwd );
+
+		Vector vecSrc	= pPlayer->EyePosition() + vecFwd * 16;
+		Vector vecThrow	= vecFwd * flVel + pPlayer->GetAbsVelocity();
+
+		QAngle angles;
+		VectorAngles( vecThrow, angles );
+#ifndef CLIENT_DLL
+		CHandGrenade *pGrenade = (CHandGrenade*)Create( "grenade_hand", vecSrc, angles );
+		if ( pGrenade )
+		{
+			// always explode 3 seconds after the pin was pulled
+			float flTime = m_flStartThrow - gpGlobals->curtime + 3.0;
+			if ( flTime < 0 )
+			{
+				flTime = 0;
+			}
+
+			pGrenade->ShootTimed( pPlayer, vecThrow, flTime );
+		}
+#endif
+
+		if ( flVel < 500 )
+		{
+			SendWeaponAnim( ACT_HANDGRENADE_THROW1 );
+		}
+		else if ( flVel < 1000 )
+		{
+			SendWeaponAnim( ACT_HANDGRENADE_THROW2 );
+		}
+		else
+		{
+			SendWeaponAnim( ACT_HANDGRENADE_THROW3 );
+		}
+
+		// player "shoot" animation
+		pPlayer->SetAnimation( PLAYER_ATTACK1 );
+
+		m_flReleaseThrow	= 0;
+		m_flStartThrow		= 0;
+
+		SetWeaponIdleTime( gpGlobals->curtime + 0.5 );
+		m_flNextPrimaryAttack	= gpGlobals->curtime + 0.5;
+		m_flNextSecondaryAttack	= gpGlobals->curtime + 0.5;
+
+		pPlayer->RemoveAmmo( 1, m_iPrimaryAmmoType );
+
+		return;
+	}
+	else if ( m_flReleaseThrow > 0 )
+	{
+		// we've finished the throw, restart.
+		m_flStartThrow = 0;
+
+		if ( pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) > 0 )
+		{
+			SendWeaponAnim( ACT_VM_DRAW );
+		}
+		else
+		{
+//			RetireWeapon();
+			return;
+		}
+
+		SetWeaponIdleTime( gpGlobals->curtime + random->RandomFloat( 10, 15 ) );
+		m_flReleaseThrow = -1;
+		return;
+	}
+
+	if ( pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) > 0 )
+	{
+		float flRand = random->RandomFloat( 0, 1 );
+		if ( flRand <= 0.75 )
+		{
+			SendWeaponAnim( ACT_VM_IDLE );
+			SetWeaponIdleTime( gpGlobals->curtime + random->RandomFloat( 10, 15 ) );// how long till we do this again.
+		}
+		else 
+		{
+			SendWeaponAnim( ACT_VM_FIDGET );
+		}
+	}
+}
+
+bool CWeaponHandGrenade::Deploy( void )
+{
+	m_flReleaseThrow = -1;
+
+	return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_VM_DRAW, (char*)GetAnimPrefix() );
+}
+
+bool CWeaponHandGrenade::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+	CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
+	if ( !pPlayer )
+	{
+		return false;
+	}
+
+	if ( m_flStartThrow > 0 )
+	{
+		return false;
+	}
+
+	if ( !BaseClass::Holster( pSwitchingTo ) )
+	{
+		return false;
+	}
+
+	if ( pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 )
+	{
+#ifndef CLIENT_DLL
+		SetThink( &CWeaponHandGrenade::DestroyItem );
+		SetNextThink( gpGlobals->curtime + 0.1 );
+#endif
+	}
+
+	pPlayer->SetNextAttack( gpGlobals->curtime + 0.5 );
+
+	return true;
+}

game/shared/hl1/hl1mp_weapon_hornetgun.cpp

@@ -0,0 +1,339 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:		Hornetgun
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "npcevent.h"
+#include "hl1mp_basecombatweapon_shared.h"
+//#include "basecombatcharacter.h"
+//#include "AI_BaseNPC.h"
+#include "gamerules.h"
+#include "in_buttons.h"
+#ifdef CLIENT_DLL
+#include "hl1/c_hl1mp_player.h"
+#else
+#include "hl1mp_player.h"
+#include "soundent.h"
+#include "game.h"
+#endif
+#include "vstdlib/random.h"
+#include "engine/IEngineSound.h"
+#if !defined(CLIENT_DLL)
+#include "hl1_npc_hornet.h"
+#endif
+
+
+//-----------------------------------------------------------------------------
+// CWeaponHgun
+//-----------------------------------------------------------------------------
+
+#ifdef CLIENT_DLL
+#define CWeaponHgun C_WeaponHgun
+#endif
+
+class CWeaponHgun : public CBaseHL1MPCombatWeapon
+{
+	DECLARE_CLASS( CWeaponHgun, CBaseHL1MPCombatWeapon );
+public:
+
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+
+	CWeaponHgun( void );
+
+	void	Precache( void );
+	void	PrimaryAttack( void );
+	void	SecondaryAttack( void );
+	void	WeaponIdle( void );
+	bool	Holster( CBaseCombatWeapon *pSwitchingTo = NULL );
+	bool	Reload( void );
+
+	virtual void ItemPostFrame( void );
+
+//	DECLARE_SERVERCLASS();
+	DECLARE_DATADESC();
+
+private:
+
+//	float	m_flRechargeTime;
+//	int		m_iFirePhase;
+
+	CNetworkVar( float,	m_flRechargeTime );
+	CNetworkVar( int,	m_iFirePhase );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponHgun, DT_WeaponHgun );
+
+BEGIN_NETWORK_TABLE( CWeaponHgun, DT_WeaponHgun )
+#ifdef CLIENT_DLL
+	RecvPropFloat( RECVINFO( m_flRechargeTime ) ),
+	RecvPropInt( RECVINFO( m_iFirePhase ) ),
+#else
+	SendPropFloat( SENDINFO( m_flRechargeTime ) ),
+	SendPropInt( SENDINFO( m_iFirePhase ) ),
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponHgun )
+#ifdef CLIENT_DLL
+	DEFINE_PRED_FIELD( m_flRechargeTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_iFirePhase, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+#endif
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_hornetgun, CWeaponHgun );
+
+PRECACHE_WEAPON_REGISTER( weapon_hornetgun );
+
+//IMPLEMENT_SERVERCLASS_ST( CWeaponHgun, DT_WeaponHgun )
+//END_SEND_TABLE()
+
+BEGIN_DATADESC( CWeaponHgun )
+	DEFINE_FIELD( m_flRechargeTime,	FIELD_TIME ),
+	DEFINE_FIELD( m_iFirePhase,		FIELD_INTEGER ),
+END_DATADESC()
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CWeaponHgun::CWeaponHgun( void )
+{
+	m_bReloadsSingly	= false;
+	m_bFiresUnderwater	= true;
+
+	m_flRechargeTime = 0.0;
+	m_iFirePhase = 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponHgun::Precache( void )
+{
+#ifndef CLIENT_DLL
+	UTIL_PrecacheOther( "hornet" );
+#endif
+
+	BaseClass::Precache();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CWeaponHgun::PrimaryAttack( void )
+{
+	CHL1_Player *pPlayer = ToHL1Player( GetOwner() );
+	if ( !pPlayer )
+	{
+		return;
+	}
+
+	if ( pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 )
+	{
+		return;
+	}
+
+	WeaponSound( SINGLE );
+#if !defined(CLIENT_DLL)
+	CSoundEnt::InsertSound( SOUND_COMBAT, GetAbsOrigin(), 200, 0.2 );
+#endif
+	pPlayer->DoMuzzleFlash();
+
+	SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+	pPlayer->SetAnimation( PLAYER_ATTACK1 );
+
+	Vector	vForward, vRight, vUp;
+	QAngle	vecAngles;
+
+	pPlayer->EyeVectors( &vForward, &vRight, &vUp );
+	VectorAngles( vForward, vecAngles );
+
+#if !defined(CLIENT_DLL)
+	CBaseEntity *pHornet = CBaseEntity::Create( "hornet", pPlayer->Weapon_ShootPosition() + vForward * 16 + vRight * 8 + vUp * -12, vecAngles, pPlayer );
+	pHornet->SetAbsVelocity( vForward * 300 );
+#endif
+
+	m_flRechargeTime = gpGlobals->curtime + 0.5;
+	
+	pPlayer->RemoveAmmo( 1, m_iPrimaryAmmoType );
+
+	pPlayer->ViewPunch( QAngle( -2, 0, 0 ) );
+
+	m_flNextPrimaryAttack = m_flNextPrimaryAttack + 0.25;
+
+	if (m_flNextPrimaryAttack < gpGlobals->curtime )
+	{
+		m_flNextPrimaryAttack = gpGlobals->curtime + 0.25;
+	}
+
+	SetWeaponIdleTime( random->RandomFloat( 10, 15 ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CWeaponHgun::SecondaryAttack( void )
+{
+	CHL1_Player *pPlayer = ToHL1Player( GetOwner() );
+	if ( !pPlayer )
+	{
+		return;
+	}
+
+	if ( pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 )
+	{
+		return;
+	}
+
+	WeaponSound( SINGLE );
+#if !defined(CLIENT_DLL)
+	CSoundEnt::InsertSound( SOUND_COMBAT, GetAbsOrigin(), 200, 0.2 );
+#endif
+	pPlayer->DoMuzzleFlash();
+
+	SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+	pPlayer->SetAnimation( PLAYER_ATTACK1 );
+
+	CBaseEntity *pHornet;
+	Vector vecSrc;
+
+	Vector	vForward, vRight, vUp;
+	QAngle	vecAngles;
+
+	pPlayer->EyeVectors( &vForward, &vRight, &vUp );
+	VectorAngles( vForward, vecAngles );
+
+	vecSrc = pPlayer->Weapon_ShootPosition() + vForward * 16 + vRight * 8 + vUp * -12;
+
+	m_iFirePhase++;
+	switch ( m_iFirePhase )
+	{
+	case 1:
+		vecSrc = vecSrc + vUp * 8;
+		break;
+	case 2:
+		vecSrc = vecSrc + vUp * 8;
+		vecSrc = vecSrc + vRight * 8;
+		break;
+	case 3:
+		vecSrc = vecSrc + vRight * 8;
+		break;
+	case 4:
+		vecSrc = vecSrc + vUp * -8;
+		vecSrc = vecSrc + vRight * 8;
+		break;
+	case 5:
+		vecSrc = vecSrc + vUp * -8;
+		break;
+	case 6:
+		vecSrc = vecSrc + vUp * -8;
+		vecSrc = vecSrc + vRight * -8;
+		break;
+	case 7:
+		vecSrc = vecSrc + vRight * -8;
+		break;
+	case 8:
+		vecSrc = vecSrc + vUp * 8;
+		vecSrc = vecSrc + vRight * -8;
+		m_iFirePhase = 0;
+		break;
+	}
+
+#ifdef CLIENT_DLL
+	pHornet = NULL;
+#else
+	pHornet = CBaseEntity::Create( "hornet", vecSrc, vecAngles, pPlayer );
+	pHornet->SetAbsVelocity( vForward * 1200 );
+	pHornet->SetThink( &CNPC_Hornet::StartDart );
+#endif
+
+	m_flRechargeTime = gpGlobals->curtime + 0.5;
+
+	pPlayer->ViewPunch( QAngle( -2, 0, 0 ) );
+	pPlayer->RemoveAmmo( 1, m_iPrimaryAmmoType );
+
+	m_flNextPrimaryAttack = m_flNextSecondaryAttack = gpGlobals->curtime + 0.1;
+	SetWeaponIdleTime( random->RandomFloat( 10, 15 ) );
+}
+
+void CWeaponHgun::WeaponIdle( void )
+{
+	if ( !HasWeaponIdleTimeElapsed() )
+		return;
+
+	int iAnim;
+	float flRand = random->RandomFloat( 0, 1 );
+	if ( flRand <= 0.75 )
+	{
+		iAnim = ACT_VM_IDLE;
+	}
+	else
+	{
+		iAnim = ACT_VM_FIDGET;
+	}
+
+	SendWeaponAnim( iAnim );
+}
+
+bool CWeaponHgun::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+	bool bRet;
+
+	bRet = BaseClass::Holster( pSwitchingTo );
+
+	if ( bRet )
+	{
+		CHL1_Player *pPlayer = ToHL1Player( GetOwner() );
+		if ( pPlayer )
+		{
+#if !defined(CLIENT_DLL)            
+			//!!!HACKHACK - can't select hornetgun if it's empty! no way to get ammo for it, either.
+            int iCount = pPlayer->GetAmmoCount( m_iPrimaryAmmoType );
+            if ( iCount <= 0 )
+            {
+                pPlayer->GiveAmmo( iCount+1, m_iPrimaryAmmoType, true );
+            }
+#endif            
+		}
+	}
+
+	return bRet;
+}
+
+bool CWeaponHgun::Reload( void )
+{
+	if ( m_flRechargeTime >= gpGlobals->curtime )
+	{
+		return true;
+	}
+
+	CHL1_Player *pPlayer = ToHL1Player( GetOwner() );
+	if ( !pPlayer )
+	{
+		return true;
+	}
+
+#ifdef CLIENT_DLL
+#else
+	if ( !g_pGameRules->CanHaveAmmo( pPlayer, m_iPrimaryAmmoType ) )
+		return true;
+
+	while ( ( m_flRechargeTime < gpGlobals->curtime ) && g_pGameRules->CanHaveAmmo( pPlayer, m_iPrimaryAmmoType ) )
+	{
+		pPlayer->GiveAmmo( 1, m_iPrimaryAmmoType, true );
+		m_flRechargeTime += 0.5;
+	}
+#endif
+
+	return true;
+}
+
+void CWeaponHgun::ItemPostFrame( void )
+{
+	Reload();
+
+	BaseClass::ItemPostFrame();
+}