1

game/shared/hl2/achievements_hl2.cpp

@@ -0,0 +1,271 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+
+#include "cbase.h"
+
+#if GAME_DLL
+
+#include "achievementmgr.h"
+#include "baseachievement.h"
+
+CAchievementMgr g_AchievementMgrHL2;	// global achievement mgr for HL2
+
+class CAchievementHL2KillBarnaclesWithOneBarrel : public CBaseAchievement
+{
+protected:
+	virtual void Init()
+	{
+		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_WITH_GAME );
+		SetInflictorFilter( "prop_physics" );
+		SetVictimFilter( "npc_barnacle" );
+		SetGoal( 1 );
+		m_pLastInflictor = NULL;
+		m_iBarnacleCount = 0;
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
+	{
+		int iDamageBits = event->GetInt( "damagebits" );
+		// only interested blast damage.  (Barrels or other explosive phys objects are all OK)
+		if ( !( iDamageBits & DMG_BLAST ) )
+			return;
+
+		if ( m_pLastInflictor != NULL && pInflictor != m_pLastInflictor )
+		{
+			m_iBarnacleCount = 1;
+		}
+		else
+		{
+			m_iBarnacleCount++;
+			if ( 5 == m_iBarnacleCount )
+			{
+				IncrementCount();
+			}			
+		}
+		m_pLastInflictor = pInflictor;
+	}
+
+	CBaseEntity *m_pLastInflictor;
+	int m_iBarnacleCount;
+};
+DECLARE_ACHIEVEMENT( CAchievementHL2KillBarnaclesWithOneBarrel, ACHIEVEMENT_HL2_KILL_BARNACLESWITHBARREL, "HL2_KILL_BARNACLESWITHBARREL", 5 );
+
+extern int CalcPlayerAttacks( bool bBulletOnly );
+
+class CAchievementHL2BeatRavenholmNoWeapons : public CFailableAchievement
+{
+	DECLARE_CLASS( CAchievementHL2BeatRavenholmNoWeapons, CFailableAchievement );
+
+	void Init()
+	{
+		SetFlags( ACH_LISTEN_MAP_EVENTS | ACH_SAVE_WITH_GAME );
+		SetGoal( 1 );
+		m_iInitialAttackCount = 0;
+	}
+
+	// map event where achievement is activated
+	virtual const char *GetActivationEventName() { return "HL2_BEAT_RAVENHOLM_NOWEAPONS_START"; }
+	// map event where achievement is evaluated for success
+	virtual const char *GetEvaluationEventName() { return "HL2_BEAT_RAVENHOLM_NOWEAPONS_END"; }
+
+	virtual void PreRestoreSavedGame() 
+	{
+		m_iInitialAttackCount = 0;
+		BaseClass::PreRestoreSavedGame();
+	}
+
+	virtual void OnActivationEvent()
+	{
+		// get current # of attacks by player w/all weapons (except grav gun) and store that
+		m_iInitialAttackCount = CalcPlayerAttacks( false );
+		BaseClass::OnActivationEvent();
+	}
+
+	virtual void OnEvaluationEvent()
+	{
+		// get current # of attacks by player w/all weapons (except grav gun) 
+		int iCurAttackCount = CalcPlayerAttacks( false );
+		// compare to # of attacks when we started
+		if ( iCurAttackCount > m_iInitialAttackCount )
+		{
+			// if there have been any more weapon attacks, achievement fails
+			SetFailed();
+		}
+		BaseClass::OnEvaluationEvent();
+	}
+
+	// additional status for debugging
+	virtual void PrintAdditionalStatus()
+	{
+		if ( m_bActivated )
+		{
+			Msg( "Starting wpn attacks: %d  Current wpn attacks: %d\n", m_iInitialAttackCount, CalcPlayerAttacks( false ) );
+		}
+	}
+
+	int m_iInitialAttackCount;
+public:
+	DECLARE_DATADESC()
+};
+DECLARE_ACHIEVEMENT( CAchievementHL2BeatRavenholmNoWeapons, ACHIEVEMENT_HL2_BEAT_RAVENHOLM_NOWEAPONS, "HL2_BEAT_RAVENHOLM_NOWEAPONS", 25 );
+
+BEGIN_DATADESC( CAchievementHL2BeatRavenholmNoWeapons )
+DEFINE_FIELD( m_iInitialAttackCount,					FIELD_INTEGER ),
+END_DATADESC()
+
+
+class CAchievementHL2KillGunships : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_WITH_GAME );
+		SetVictimFilter( "npc_combinegunship" );
+		SetGoal( 6 );	// note: goal is really six, although #define is "THREEGUNSHIPS"
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementHL2KillGunships, ACHIEVEMENT_HL2_KILL_THREEGUNSHIPS, "HL2_KILL_THREEGUNSHIPS", 5 );
+
+class CAchievementHL2KillEnemiesWithAntlions : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_LISTEN_KILL_ENEMY_EVENTS | ACH_SAVE_WITH_GAME );
+		SetInflictorFilter( "npc_antlion" );
+		SetGoal( 50 );
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
+	{
+		CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
+		if ( pPlayer )
+		{
+			// Only count antlion kills once player owns bugbait. 
+			if ( pPlayer->Weapon_OwnsThisType( "weapon_bugbait" ) )
+			{
+				IncrementCount();
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementHL2KillEnemiesWithAntlions, ACHIEVEMENT_HL2_KILL_ENEMIES_WITHANTLIONS, "HL2_KILL_ENEMIES_WITHANTLIONS", 10 );
+
+class CAchievementHL2KillEnemyWithToilet : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_WITH_GAME );
+		SetInflictorFilter( "prop_physics" );
+		SetGoal( 1 );
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
+	{
+		const char *pszName = GetModelName( pInflictor );
+
+		// skip past any directories and get just the file name
+		pszName = V_UnqualifiedFileName( pszName );
+		// if model name matches one of the toilets, this counts
+		if ( ( 0 == Q_stricmp( pszName, "FurnitureToilet001a.mdl" ) ) || ( 0 == Q_stricmp( pszName, "prison_toilet01.mdl" ) ) )
+		{
+			IncrementCount();
+		}		
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementHL2KillEnemyWithToilet, ACHIEVEMENT_HL2_KILL_ENEMY_WITHTOILET, "HL2_KILL_ENEMY_WITHTOILET", 5 );
+
+class CAchievementHL2DisintegrateSoldiersInField : public CBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_WITH_GAME );
+		SetGoal( 15 );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "ragdoll_dissolved" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( 0 == Q_strcmp( event->GetName(), "ragdoll_dissolved" ) )
+		{
+			CBaseEntity *pRagdoll = UTIL_EntityByIndex( event->GetInt( "entindex", 0 ) );
+			if ( pRagdoll )
+			{
+				const char *pszName = GetModelName( pRagdoll );
+
+				// skip past any directories and get just the file name
+				pszName = V_UnqualifiedFileName( pszName );
+	
+				if ( ( 0 == Q_stricmp( pszName, "combine_soldier.mdl" ) ) ||
+					( 0 == Q_stricmp( pszName, "combine_super_soldier.mdl" ) ) )
+				{
+					IncrementCount();
+				}							
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementHL2DisintegrateSoldiersInField, ACHIEVEMENT_HL2_DISINTEGRATE_SOLDIERSINFIELD, "HL2_DISINTEGRATE_SOLDIERSINFIELD", 10 );
+
+class CAchievementHL2FindAllLambdas : public CBaseAchievement
+{
+	virtual void Init()
+	{
+		static const char *szComponents[] =
+		{
+			"HL2_LAMDACACHE_KLEINERSLAB", "HL2_LAMDACACHE_CANALSSTATION", "HL2_LAMDACACHE_VENTCRAWL", "HL2_LAMDACACHE_CANALSTUNNEL",
+			"HL2_LAMDACACHE_SEWERGRATE", "HL2_LAMDACACHE_STEAMPIPE", "HL2_LAMDACACHE_CURVEDROOM", "HL2_LAMDACACHE_SHANTYTOWN",
+			"HL2_LAMDACACHE_TUNNELLADDER", "HL2_LAMDACACHE_REDBARN", "HL2_LAMDACACHE_ZOMBIEAMBUSH", "HL2_LAMDACACHE_BELOWAPCS",
+			"HL2_LAMDACACHE_COUNTERWEIGHT", "HL2_LAMDACACHE_RAILWAYBRIDGE", "HL2_LAMDACACHE_TUNNELPLATFORMS", "HL2_LAMDACACHE_BANKEDCANAL",
+			"HL2_LAMDACACHE_CANALWALL", "HL2_LAMDACACHE_CHANNELSPLIT", "HL2_LAMDACACHE_BMEDOCK", "HL2_LAMDACACHE_GENERATORS",
+			"HL2_LAMDACACHE_CARCRUSHERARENA", "HL2_LAMDACACHE_RAVENHOLMATTIC", "HL2_LAMDACACHE_MINETUNNELEXIT", 
+			"HL2_LAMDACACHE_COASTSHACK", "HL2_LAMDACACHE_POISONSHACK", "HL2_LAMDACACHE_GUNSHIPVAN", "HL2_LAMDACACHE_SUICIDECITIZEN",
+			"HL2_LAMDACACHE_RAILROADSHACK", "HL2_LAMDACACHE_COASTABOVEBATTERY", "HL2_LAMDACACHE_SANDSHACK", "HL2_LAMDACACHE_GMANCACHE",
+			"HL2_LAMDACACHE_CELLCACHE", "HL2_LAMDACACHE_POISONLAUNDRY", "HL2_LAMDACACHE_SODAMACHINE",
+			"HL2_LAMDACACHE_STREETWARDOGWALL", "HL2_LAMDACACHE_STREETWARSHACK", "HL2_LAMDACACHE_STREETWARFENCE", "HL2_LAMDACACHE_FREEWAYTUNNEL", "HL2_LAMDACACHE_DRAWBRIDGE",
+			"HL2_LAMDACACHE_PLAZAFENCE", "HL2_LAMDACACHE_SEWERSCATWALKS", "HL2_LAMDACACHE_POISONZOMBIEALCOVE", "HL2_LAMDACACHE_PIPEHOPTUNNEL",
+			"HL2_LAMDACACHE_ENDOFC1712B", "HL2_LAMDACACHE_EXITCATWALK"
+		};		
+		SetFlags( ACH_HAS_COMPONENTS | ACH_LISTEN_COMPONENT_EVENTS | ACH_SAVE_GLOBAL );
+		m_pszComponentNames = szComponents;
+		m_iNumComponents = ARRAYSIZE( szComponents );
+		SetComponentPrefix( "HL2_LAMDACACHE" );
+		SetGoal( m_iNumComponents );
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementHL2FindAllLambdas, ACHIEVEMENT_HL2_FIND_ALLLAMBDAS, "HL2_FIND_ALLLAMBDAS", 15 );
+
+// achievements which are won by a map event firing once
+DECLARE_MAP_EVENT_ACHIEVEMENT_HIDDEN( ACHIEVEMENT_HL2_HIT_CANCOP_WITHCAN, "HL2_HIT_CANCOP_WITHCAN", 5 );
+DECLARE_MAP_EVENT_ACHIEVEMENT_HIDDEN( ACHIEVEMENT_HL2_PUT_CANINTRASH, "HL2_PUT_CANINTRASH", 5 );
+DECLARE_MAP_EVENT_ACHIEVEMENT( ACHIEVEMENT_HL2_ESCAPE_APARTMENTRAID, "HL2_ESCAPE_APARTMENTRAID", 5 );
+DECLARE_MAP_EVENT_ACHIEVEMENT( ACHIEVEMENT_HL2_BREAK_MINITELEPORTER, "HL2_BREAK_MINITELEPORTER", 5 );
+DECLARE_MAP_EVENT_ACHIEVEMENT( ACHIEVEMENT_HL2_GET_CROWBAR, "HL2_GET_CROWBAR", 5 );
+DECLARE_MAP_EVENT_ACHIEVEMENT( ACHIEVEMENT_HL2_GET_AIRBOAT, "HL2_GET_AIRBOAT", 5 );
+DECLARE_MAP_EVENT_ACHIEVEMENT( ACHIEVEMENT_HL2_GET_AIRBOATGUN, "HL2_GET_AIRBOATGUN", 5 );
+DECLARE_MAP_EVENT_ACHIEVEMENT( ACHIEVEMENT_HL2_FIND_VORTIGAUNTCAVE, "HL2_FIND_VORTIGAUNTCAVE", 13 );
+DECLARE_MAP_EVENT_ACHIEVEMENT( ACHIEVEMENT_HL2_KILL_CHOPPER, "HL2_KILL_CHOPPER", 10 );
+DECLARE_MAP_EVENT_ACHIEVEMENT( ACHIEVEMENT_HL2_FIND_HEVFACEPLATE, "HL2_FIND_HEVFACEPLATE", 10 );
+DECLARE_MAP_EVENT_ACHIEVEMENT( ACHIEVEMENT_HL2_GET_GRAVITYGUN, "HL2_GET_GRAVITYGUN", 5 );
+DECLARE_MAP_EVENT_ACHIEVEMENT( ACHIEVEMENT_HL2_MAKEABASKET, "HL2_MAKEABASKET", 2 );
+DECLARE_MAP_EVENT_ACHIEVEMENT_HIDDEN( ACHIEVEMENT_HL2_BEAT_CEMETERY, "HL2_BEAT_CEMETERY", 5 );
+DECLARE_MAP_EVENT_ACHIEVEMENT( ACHIEVEMENT_HL2_KILL_ENEMIES_WITHCRANE, "HL2_KILL_ENEMIES_WITHCRANE", 5 );	
+DECLARE_MAP_EVENT_ACHIEVEMENT( ACHIEVEMENT_HL2_PIN_SOLDIER_TOBILLBOARD, "HL2_PIN_SOLDIER_TOBILLBOARD", 5 );		
+DECLARE_MAP_EVENT_ACHIEVEMENT_HIDDEN( ACHIEVEMENT_HL2_KILL_ODESSAGUNSHIP, "HL2_KILL_ODESSAGUNSHIP", 5 );				
+DECLARE_MAP_EVENT_ACHIEVEMENT( ACHIEVEMENT_HL2_BEAT_DONTTOUCHSAND, "HL2_BEAT_DONTTOUCHSAND", 20 );
+DECLARE_MAP_EVENT_ACHIEVEMENT( ACHIEVEMENT_HL2_BEAT_TURRETSTANDOFF2, "HL2_BEAT_TURRETSTANDOFF2", 10 );			
+DECLARE_MAP_EVENT_ACHIEVEMENT( ACHIEVEMENT_HL2_FOLLOW_FREEMAN, "HL2_FOLLOWFREEMAN", 10 );
+DECLARE_MAP_EVENT_ACHIEVEMENT( ACHIEVEMENT_HL2_BEAT_TOXICTUNNEL, "HL2_BEAT_TOXICTUNNEL", 5 );
+DECLARE_MAP_EVENT_ACHIEVEMENT( ACHIEVEMENT_HL2_BEAT_PLAZASTANDOFF, "HL2_BEAT_PLAZASTANDOFF", 10 );
+DECLARE_MAP_EVENT_ACHIEVEMENT( ACHIEVEMENT_HL2_KILL_ALLC1709SNIPERS, "HL2_KILL_ALLC1709SNIPERS", 5 );
+DECLARE_MAP_EVENT_ACHIEVEMENT( ACHIEVEMENT_HL2_BEAT_SUPRESSIONDEVICE, "HL2_BEAT_SUPRESSIONDEVICE", 10 );
+DECLARE_MAP_EVENT_ACHIEVEMENT( ACHIEVEMENT_HL2_BEAT_C1713STRIDERSTANDOFF, "HL2_BEAT_C1713STRIDERSTANDOFF", 10 );
+DECLARE_MAP_EVENT_ACHIEVEMENT_HIDDEN( ACHIEVEMENT_HL2_BEAT_GAME, "HL2_BEAT_GAME", 25 );
+
+#endif // GAME_DLL

game/shared/hl2/basehlcombatweapon_shared.cpp

@@ -0,0 +1,431 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "basehlcombatweapon_shared.h"
+
+#include "hl2_player_shared.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+LINK_ENTITY_TO_CLASS( basehlcombatweapon, CBaseHLCombatWeapon );
+
+IMPLEMENT_NETWORKCLASS_ALIASED( BaseHLCombatWeapon , DT_BaseHLCombatWeapon )
+
+BEGIN_NETWORK_TABLE( CBaseHLCombatWeapon , DT_BaseHLCombatWeapon )
+#if !defined( CLIENT_DLL )
+//	SendPropInt( SENDINFO( m_bReflectViewModelAnimations ), 1, SPROP_UNSIGNED ),
+#else
+//	RecvPropInt( RECVINFO( m_bReflectViewModelAnimations ) ),
+#endif
+END_NETWORK_TABLE()
+
+
+#if !defined( CLIENT_DLL )
+
+#include "globalstate.h"
+
+//---------------------------------------------------------
+// Save/Restore
+//---------------------------------------------------------
+BEGIN_DATADESC( CBaseHLCombatWeapon )
+
+	DEFINE_FIELD( m_bLowered,			FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_flRaiseTime,		FIELD_TIME ),
+	DEFINE_FIELD( m_flHolsterTime,		FIELD_TIME ),
+	DEFINE_FIELD( m_iPrimaryAttacks,	FIELD_INTEGER ),
+	DEFINE_FIELD( m_iSecondaryAttacks,	FIELD_INTEGER ),
+
+END_DATADESC()
+
+#endif
+
+BEGIN_PREDICTION_DATA( CBaseHLCombatWeapon )
+END_PREDICTION_DATA()
+
+ConVar sk_auto_reload_time( "sk_auto_reload_time", "3", FCVAR_REPLICATED );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseHLCombatWeapon::ItemHolsterFrame( void )
+{
+	BaseClass::ItemHolsterFrame();
+
+	// Must be player held
+	if ( GetOwner() && GetOwner()->IsPlayer() == false )
+		return;
+
+	// We can't be active
+	if ( GetOwner()->GetActiveWeapon() == this )
+		return;
+
+	// If it's been longer than three seconds, reload
+	if ( ( gpGlobals->curtime - m_flHolsterTime ) > sk_auto_reload_time.GetFloat() )
+	{
+		// Just load the clip with no animations
+		FinishReload();
+		m_flHolsterTime = gpGlobals->curtime;
+	}
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CBaseHLCombatWeapon::CanLower()
+{
+	if ( SelectWeightedSequence( ACT_VM_IDLE_LOWERED ) == ACTIVITY_NOT_AVAILABLE )
+		return false;
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Drops the weapon into a lowered pose
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CBaseHLCombatWeapon::Lower( void )
+{
+	//Don't bother if we don't have the animation
+	if ( SelectWeightedSequence( ACT_VM_IDLE_LOWERED ) == ACTIVITY_NOT_AVAILABLE )
+		return false;
+
+	m_bLowered = true;
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Brings the weapon up to the ready position
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CBaseHLCombatWeapon::Ready( void )
+{
+	//Don't bother if we don't have the animation
+	if ( SelectWeightedSequence( ACT_VM_LOWERED_TO_IDLE ) == ACTIVITY_NOT_AVAILABLE )
+		return false;
+
+	m_bLowered = false;	
+	m_flRaiseTime = gpGlobals->curtime + 0.5f;
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CBaseHLCombatWeapon::Deploy( void )
+{
+	// If we should be lowered, deploy in the lowered position
+	// We have to ask the player if the last time it checked, the weapon was lowered
+	if ( GetOwner() && GetOwner()->IsPlayer() )
+	{
+		CHL2_Player *pPlayer = assert_cast<CHL2_Player*>( GetOwner() );
+		if ( pPlayer->IsWeaponLowered() )
+		{
+			if ( SelectWeightedSequence( ACT_VM_IDLE_LOWERED ) != ACTIVITY_NOT_AVAILABLE )
+			{
+				if ( DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_VM_IDLE_LOWERED, (char*)GetAnimPrefix() ) )
+				{
+					m_bLowered = true;
+
+					// Stomp the next attack time to fix the fact that the lower idles are long
+					pPlayer->SetNextAttack( gpGlobals->curtime + 1.0 );
+					m_flNextPrimaryAttack = gpGlobals->curtime + 1.0;
+					m_flNextSecondaryAttack	= gpGlobals->curtime + 1.0;
+					return true;
+				}
+			}
+		}
+	}
+
+	m_bLowered = false;
+	return BaseClass::Deploy();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CBaseHLCombatWeapon::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+	if ( BaseClass::Holster( pSwitchingTo ) )
+	{
+		m_flHolsterTime = gpGlobals->curtime;
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CBaseHLCombatWeapon::WeaponShouldBeLowered( void )
+{
+	// Can't be in the middle of another animation
+  	if ( GetIdealActivity() != ACT_VM_IDLE_LOWERED && GetIdealActivity() != ACT_VM_IDLE &&
+		 GetIdealActivity() != ACT_VM_IDLE_TO_LOWERED && GetIdealActivity() != ACT_VM_LOWERED_TO_IDLE )
+  		return false;
+
+	if ( m_bLowered )
+		return true;
+	
+#if !defined( CLIENT_DLL )
+
+	if ( GlobalEntity_GetState( "friendly_encounter" ) == GLOBAL_ON )
+		return true;
+
+#endif
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Allows the weapon to choose proper weapon idle animation
+//-----------------------------------------------------------------------------
+void CBaseHLCombatWeapon::WeaponIdle( void )
+{
+	//See if we should idle high or low
+	if ( WeaponShouldBeLowered() )
+	{
+#if !defined( CLIENT_DLL )
+		CHL2_Player *pPlayer = dynamic_cast<CHL2_Player*>(GetOwner());
+
+		if( pPlayer )
+		{
+			pPlayer->Weapon_Lower();
+		}
+#endif
+
+		// Move to lowered position if we're not there yet
+		if ( GetActivity() != ACT_VM_IDLE_LOWERED && GetActivity() != ACT_VM_IDLE_TO_LOWERED 
+			 && GetActivity() != ACT_TRANSITION )
+		{
+			SendWeaponAnim( ACT_VM_IDLE_LOWERED );
+		}
+		else if ( HasWeaponIdleTimeElapsed() )
+		{
+			// Keep idling low
+			SendWeaponAnim( ACT_VM_IDLE_LOWERED );
+		}
+	}
+	else
+	{
+		// See if we need to raise immediately
+		if ( m_flRaiseTime < gpGlobals->curtime && GetActivity() == ACT_VM_IDLE_LOWERED ) 
+		{
+			SendWeaponAnim( ACT_VM_IDLE );
+		}
+		else if ( HasWeaponIdleTimeElapsed() ) 
+		{
+			SendWeaponAnim( ACT_VM_IDLE );
+		}
+	}
+}
+
+float	g_lateralBob;
+float	g_verticalBob;
+
+#if defined( CLIENT_DLL ) && ( !defined( HL2MP ) && !defined( PORTAL ) )
+
+#define	HL2_BOB_CYCLE_MIN	1.0f
+#define	HL2_BOB_CYCLE_MAX	0.45f
+#define	HL2_BOB			0.002f
+#define	HL2_BOB_UP		0.5f
+
+
+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 CBaseHLCombatWeapon::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/HL2_BOB_CYCLE_MAX)*HL2_BOB_CYCLE_MAX;
+	cycle /= HL2_BOB_CYCLE_MAX;
+
+	if ( cycle < HL2_BOB_UP )
+	{
+		cycle = M_PI * cycle / HL2_BOB_UP;
+	}
+	else
+	{
+		cycle = M_PI + M_PI*(cycle-HL2_BOB_UP)/(1.0 - HL2_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/HL2_BOB_CYCLE_MAX*2)*HL2_BOB_CYCLE_MAX*2;
+	cycle /= HL2_BOB_CYCLE_MAX*2;
+
+	if ( cycle < HL2_BOB_UP )
+	{
+		cycle = M_PI * cycle / HL2_BOB_UP;
+	}
+	else
+	{
+		cycle = M_PI + M_PI*(cycle-HL2_BOB_UP)/(1.0 - HL2_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 CBaseHLCombatWeapon::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 );
+}
+
+//-----------------------------------------------------------------------------
+Vector CBaseHLCombatWeapon::GetBulletSpread( WeaponProficiency_t proficiency )
+{
+	return BaseClass::GetBulletSpread( proficiency );
+}
+
+//-----------------------------------------------------------------------------
+float CBaseHLCombatWeapon::GetSpreadBias( WeaponProficiency_t proficiency )
+{
+	return BaseClass::GetSpreadBias( proficiency );
+}
+//-----------------------------------------------------------------------------
+
+const WeaponProficiencyInfo_t *CBaseHLCombatWeapon::GetProficiencyValues()
+{
+	return NULL;
+}
+
+#else
+
+// Server stubs
+float CBaseHLCombatWeapon::CalcViewmodelBob( void )
+{
+	return 0.0f;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : &origin - 
+//			&angles - 
+//			viewmodelindex - 
+//-----------------------------------------------------------------------------
+void CBaseHLCombatWeapon::AddViewmodelBob( CBaseViewModel *viewmodel, Vector &origin, QAngle &angles )
+{
+}
+
+
+//-----------------------------------------------------------------------------
+Vector CBaseHLCombatWeapon::GetBulletSpread( WeaponProficiency_t proficiency )
+{
+	Vector baseSpread = BaseClass::GetBulletSpread( proficiency );
+
+	const WeaponProficiencyInfo_t *pProficiencyValues = GetProficiencyValues();
+	float flModifier = (pProficiencyValues)[ proficiency ].spreadscale;
+	return ( baseSpread * flModifier );
+}
+
+//-----------------------------------------------------------------------------
+float CBaseHLCombatWeapon::GetSpreadBias( WeaponProficiency_t proficiency )
+{
+	const WeaponProficiencyInfo_t *pProficiencyValues = GetProficiencyValues();
+	return (pProficiencyValues)[ proficiency ].bias;
+}
+
+//-----------------------------------------------------------------------------
+const WeaponProficiencyInfo_t *CBaseHLCombatWeapon::GetProficiencyValues()
+{
+	return GetDefaultProficiencyValues();
+}
+
+//-----------------------------------------------------------------------------
+const WeaponProficiencyInfo_t *CBaseHLCombatWeapon::GetDefaultProficiencyValues()
+{
+	// Weapon proficiency table. Keep this in sync with WeaponProficiency_t enum in the header!!
+	static WeaponProficiencyInfo_t g_BaseWeaponProficiencyTable[] =
+	{
+		{ 2.50, 1.0	},
+		{ 2.00, 1.0	},
+		{ 1.50, 1.0	},
+		{ 1.25, 1.0 },
+		{ 1.00, 1.0	},
+	};
+
+	COMPILE_TIME_ASSERT( ARRAYSIZE(g_BaseWeaponProficiencyTable) == WEAPON_PROFICIENCY_PERFECT + 1);
+
+	return g_BaseWeaponProficiencyTable;
+}
+
+#endif

game/shared/hl2/basehlcombatweapon_shared.h

@@ -0,0 +1,66 @@
+//========= 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 CBaseHLCombatWeapon C_BaseHLCombatWeapon
+#endif
+
+class CBaseHLCombatWeapon : public CBaseCombatWeapon
+{
+#if !defined( CLIENT_DLL )
+#ifndef _XBOX
+	DECLARE_DATADESC();
+#else
+protected:
+	DECLARE_DATADESC();
+private:
+#endif
+#endif
+
+	DECLARE_CLASS( CBaseHLCombatWeapon, CBaseCombatWeapon );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	virtual bool	WeaponShouldBeLowered( void );
+
+			bool	CanLower();
+	virtual bool	Ready( void );
+	virtual bool	Lower( void );
+	virtual bool	Deploy( void );
+	virtual bool	Holster( CBaseCombatWeapon *pSwitchingTo );
+	virtual void	WeaponIdle( void );
+
+	virtual void	AddViewmodelBob( CBaseViewModel *viewmodel, Vector &origin, QAngle &angles );
+	virtual	float	CalcViewmodelBob( void );
+
+	virtual Vector	GetBulletSpread( WeaponProficiency_t proficiency );
+	virtual float	GetSpreadBias( WeaponProficiency_t proficiency );
+
+	virtual const	WeaponProficiencyInfo_t *GetProficiencyValues();
+	static const	WeaponProficiencyInfo_t *GetDefaultProficiencyValues();
+
+	virtual void	ItemHolsterFrame( void );
+
+	int				m_iPrimaryAttacks;		// # of primary attacks performed with this weapon
+	int				m_iSecondaryAttacks;	// # of secondary attacks performed with this weapon
+
+protected:
+
+	bool			m_bLowered;			// Whether the viewmodel is raised or lowered
+	float			m_flRaiseTime;		// If lowered, the time we should raise the viewmodel
+	float			m_flHolsterTime;	// When the weapon was holstered
+};
+
+#endif // BASEHLCOMBATWEAPON_SHARED_H

game/shared/hl2/citadel_effects_shared.h

@@ -0,0 +1,62 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef CITADEL_EFFECTS_SHARED_H
+#define CITADEL_EFFECTS_SHARED_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#define	SF_ENERGYCORE_NO_PARTICLES	(1<<0)
+#define	SF_ENERGYCORE_START_ON		(1<<1)
+
+enum
+{
+	ENERGYCORE_STATE_OFF,
+	ENERGYCORE_STATE_CHARGING,
+	ENERGYCORE_STATE_DISCHARGING,
+};
+
+#ifndef CLIENT_DLL
+
+// ============================================================================
+//
+//  Energy core - charges up and then releases energy from its position
+//
+// ============================================================================
+
+class CCitadelEnergyCore : public CBaseEntity
+{
+	DECLARE_CLASS( CCitadelEnergyCore, CBaseEntity );
+	DECLARE_SERVERCLASS();
+	DECLARE_DATADESC();
+
+public:
+	void	InputStartCharge( inputdata_t &inputdata );
+	void	InputStartDischarge( inputdata_t &inputdata );
+	void	InputStop( inputdata_t &inputdata );
+	void	SetScale( float flScale ) { m_flScale = flScale; }
+
+	void	StartCharge( float flWarmUpTime );
+	void	StartDischarge();
+	void	StopDischarge( float flCoolDownTime );
+
+	virtual int	ShouldTransmit( const CCheckTransmitInfo *pInfo );
+	virtual int UpdateTransmitState( void );
+
+	virtual void Precache();
+	void	Spawn( void );
+
+private:
+	CNetworkVar( float, m_flScale );
+	CNetworkVar( int, m_nState );
+	CNetworkVar( float, m_flDuration );
+	CNetworkVar( float, m_flStartTime );
+};
+
+#endif
+
+#endif // CITADEL_EFFECTS_SHARED_H

game/shared/hl2/env_alyxemp_shared.h

@@ -0,0 +1,63 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef ENV_ALYXEMP_SHARED_H
+#define ENV_ALYXEMP_SHARED_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "beam_shared.h"
+
+enum
+{
+	ALYXEMP_STATE_OFF,
+	ALYXEMP_STATE_CHARGING,
+	ALYXEMP_STATE_DISCHARGING,
+};
+
+class CAlyxEmpEffect : public CBaseEntity
+{
+	DECLARE_CLASS( CAlyxEmpEffect, CBaseEntity );
+	DECLARE_SERVERCLASS();
+	DECLARE_DATADESC();
+
+public:
+
+	void	InputStartCharge( inputdata_t &inputdata );
+	void	InputStartDischarge( inputdata_t &inputdata );
+	void	InputStop( inputdata_t &inputdata );
+	void	InputSetTargetEnt( inputdata_t &inputdata );
+
+	void	StartCharge( float flDuration );
+	void	StartDischarge();
+	void	Stop( float flDuration );
+	void	SetTargetEntity( CBaseEntity *pTarget );
+
+	void	ActivateAutomatic( CBaseEntity *pAlyx, CBaseEntity *pTarget );
+	void	AutomaticThink();
+
+	void	Spawn( void );
+	void	Precache( void );
+	void	Activate( void );
+
+private:
+
+	void	SetTargetEntity( const char *szEntityName );
+	CHandle<CBeam>			m_hBeam;
+	CHandle<CBaseEntity>	m_hTargetEnt;
+	string_t				m_strTargetName;
+	int						m_nType;			// What type of effect this is (small, large)
+	int						m_iState;
+	bool					m_bAutomated;
+
+	CNetworkVar( int, m_nState );
+	CNetworkVar( float, m_flDuration );
+	CNetworkVar( float, m_flStartTime );
+};
+
+
+#endif // ENV_ALYXEMP_SHARED_H

game/shared/hl2/env_headcrabcanister_shared.cpp

@@ -0,0 +1,393 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "env_headcrabcanister_shared.h"
+#include "mapdata_shared.h"
+#include "sharedInterface.h"
+#include "mathlib/vmatrix.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#define ROTATION_SPEED 90.0f
+
+
+BEGIN_SIMPLE_DATADESC( CEnvHeadcrabCanisterShared )
+	DEFINE_FIELD( m_vecStartPosition,			FIELD_POSITION_VECTOR ),
+	DEFINE_FIELD( m_vecEnterWorldPosition,		FIELD_POSITION_VECTOR ),
+	DEFINE_FIELD( m_vecDirection,				FIELD_VECTOR ),
+	DEFINE_FIELD( m_vecStartAngles,				FIELD_VECTOR ),
+	DEFINE_KEYFIELD( m_flLaunchHeight,			FIELD_FLOAT,	"StartingHeight" ),
+	DEFINE_KEYFIELD( m_flFlightSpeed,			FIELD_FLOAT,	"FlightSpeed" ),
+	DEFINE_KEYFIELD( m_flFlightTime,			FIELD_FLOAT,	"FlightTime" ),
+	DEFINE_FIELD( m_flLaunchTime,				FIELD_TIME ),
+	DEFINE_FIELD( m_flWorldEnterTime,			FIELD_FLOAT ),
+	DEFINE_FIELD( m_flInitialZSpeed,			FIELD_FLOAT ),
+	DEFINE_FIELD( m_flZAcceleration,			FIELD_FLOAT ),
+	DEFINE_FIELD( m_flHorizSpeed,				FIELD_FLOAT ),
+	DEFINE_FIELD( m_bLaunchedFromWithinWorld,	FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_vecSkyboxOrigin,			FIELD_VECTOR ),
+	DEFINE_FIELD( m_vecParabolaDirection,		FIELD_VECTOR ),
+	DEFINE_FIELD( m_flSkyboxScale,				FIELD_FLOAT ),
+	DEFINE_FIELD( m_bInSkybox,					FIELD_BOOLEAN ),
+END_DATADESC()
+
+
+BEGIN_NETWORK_TABLE_NOBASE( CEnvHeadcrabCanisterShared, DT_EnvHeadcrabCanisterShared )
+
+#if !defined( CLIENT_DLL )
+	SendPropFloat	( SENDINFO( m_flFlightSpeed ),			0, SPROP_NOSCALE ),	
+	SendPropTime	( SENDINFO( m_flLaunchTime ) ),
+	SendPropVector	( SENDINFO( m_vecParabolaDirection ),	0, SPROP_NOSCALE ),	
+
+	SendPropFloat	( SENDINFO( m_flFlightTime ),			0, SPROP_NOSCALE ),
+	SendPropFloat	( SENDINFO( m_flWorldEnterTime ),		0, SPROP_NOSCALE ),
+
+	SendPropFloat	( SENDINFO( m_flInitialZSpeed ),		0, SPROP_NOSCALE ),
+	SendPropFloat	( SENDINFO( m_flZAcceleration ),		0, SPROP_NOSCALE ),
+	SendPropFloat	( SENDINFO( m_flHorizSpeed ),			0, SPROP_NOSCALE ),
+	SendPropBool	( SENDINFO( m_bLaunchedFromWithinWorld ) ),
+	
+	SendPropVector	( SENDINFO( m_vecStartPosition ),       0, SPROP_NOSCALE ),	
+	SendPropVector	( SENDINFO( m_vecEnterWorldPosition ),  0, SPROP_NOSCALE ),	
+	SendPropVector	( SENDINFO( m_vecDirection ),			0, SPROP_NOSCALE ),	
+	SendPropVector	( SENDINFO( m_vecStartAngles ),			0, SPROP_NOSCALE ),	
+
+	SendPropVector	( SENDINFO( m_vecSkyboxOrigin ),		0, SPROP_NOSCALE ),	
+	SendPropFloat	( SENDINFO( m_flSkyboxScale ),			0, SPROP_NOSCALE ),
+	SendPropBool	( SENDINFO( m_bInSkybox ) ),
+#else
+	RecvPropFloat	( RECVINFO( m_flFlightSpeed ) ),	
+	RecvPropTime	( RECVINFO( m_flLaunchTime ) ),
+	RecvPropVector	( RECVINFO( m_vecParabolaDirection ) ),	
+
+	RecvPropFloat	( RECVINFO( m_flFlightTime ) ),	
+	RecvPropFloat	( RECVINFO( m_flWorldEnterTime ) ),	
+
+	RecvPropFloat	( RECVINFO( m_flInitialZSpeed ) ),	
+	RecvPropFloat	( RECVINFO( m_flZAcceleration ) ),	
+	RecvPropFloat	( RECVINFO( m_flHorizSpeed ) ),	
+	RecvPropBool	( RECVINFO( m_bLaunchedFromWithinWorld ) ),	
+
+	RecvPropVector	( RECVINFO( m_vecStartPosition ) ),	
+	RecvPropVector	( RECVINFO( m_vecEnterWorldPosition ) ),	
+	RecvPropVector	( RECVINFO( m_vecDirection ) ),	
+	RecvPropVector	( RECVINFO( m_vecStartAngles ) ),	
+
+	RecvPropVector	( RECVINFO( m_vecSkyboxOrigin ) ),	
+	RecvPropFloat	( RECVINFO( m_flSkyboxScale ) ),	
+	RecvPropBool	( RECVINFO( m_bInSkybox ) ),	
+#endif
+
+END_NETWORK_TABLE()
+
+
+
+//=============================================================================
+//
+// HeadcrabCanister Functions.
+//
+
+//-----------------------------------------------------------------------------
+// Constructor
+//-----------------------------------------------------------------------------
+CEnvHeadcrabCanisterShared::CEnvHeadcrabCanisterShared()
+{
+	m_vecStartPosition.Init();
+	m_vecDirection.Init();
+	m_flFlightSpeed = 0.0f;
+
+	// This tells the client DLL to not draw trails, etc.
+	m_flLaunchTime = -1.0f;
+
+	m_flWorldEnterTime = 0.0f;
+	m_flFlightTime = 0.0f;
+	m_bInSkybox = false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Creates a headcrab canister in the world
+//-----------------------------------------------------------------------------
+void CEnvHeadcrabCanisterShared::InitInWorld( float flLaunchTime, 
+	const Vector &vecStartPosition, const QAngle &vecStartAngles, 
+	const Vector &vecDirection, const Vector &vecImpactPosition, bool bLaunchedFromWithinWorld )
+{
+	Vector vecActualStartPosition = vecStartPosition;
+	if ( !bLaunchedFromWithinWorld )
+	{
+		// Move the start position inward if it's too close
+		Vector vecDelta;
+		VectorSubtract( vecStartPosition, vecImpactPosition, vecDelta );
+		VectorNormalize( vecDelta );
+
+		VectorMA( vecImpactPosition, m_flFlightTime * m_flFlightSpeed, vecDelta, vecActualStartPosition );
+	}
+ 
+	// Setup initial parametric state.
+	m_flLaunchTime = flLaunchTime;
+	m_vecStartPosition = vecActualStartPosition;
+	m_vecEnterWorldPosition = vecActualStartPosition;
+	m_vecDirection = vecDirection;
+	m_vecStartAngles = vecStartAngles;
+	m_flWorldEnterTime = 0.0f;
+	m_bInSkybox = false;
+	m_bLaunchedFromWithinWorld = bLaunchedFromWithinWorld;
+ 
+	if ( m_bLaunchedFromWithinWorld )
+	{
+		m_flSkyboxScale = 1;
+		m_vecSkyboxOrigin = vec3_origin;
+
+		float flLength = m_vecDirection.Get().AsVector2D().Length();
+		VectorSubtract(vecImpactPosition, vecStartPosition, m_vecParabolaDirection.GetForModify());
+		m_vecParabolaDirection.GetForModify().z = 0;
+		float flTotalDistance = VectorNormalize( m_vecParabolaDirection.GetForModify() );
+		m_vecDirection.GetForModify().x = flLength * m_vecParabolaDirection.Get().x;
+		m_vecDirection.GetForModify().y = flLength * m_vecParabolaDirection.Get().y;
+ 
+		m_flHorizSpeed = flTotalDistance / m_flFlightTime;
+		m_flWorldEnterTime = 0;
+ 
+		float flFinalZSpeed = m_vecDirection.Get().z * m_flHorizSpeed;
+		m_flFlightSpeed = sqrt( m_flHorizSpeed * m_flHorizSpeed + flFinalZSpeed * flFinalZSpeed );
+		m_flInitialZSpeed = (2.0f * ( vecImpactPosition.z - vecStartPosition.z ) - flFinalZSpeed * m_flFlightTime) / m_flFlightTime;
+		m_flZAcceleration = (flFinalZSpeed - m_flInitialZSpeed) / m_flFlightTime;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Creates a headcrab canister in the skybox
+//-----------------------------------------------------------------------------
+void CEnvHeadcrabCanisterShared::InitInSkybox( float flLaunchTime, 
+	const Vector &vecStartPosition, const QAngle &vecStartAngles, const Vector &vecDirection,
+	const Vector &vecImpactPosition, const Vector &vecSkyboxOrigin, float flSkyboxScale )
+{
+	// Compute a horizontal speed (constant)
+	m_vecParabolaDirection.Init( vecDirection.x, vecDirection.y, 0.0f );
+	float flLength = VectorNormalize( m_vecParabolaDirection.GetForModify() ); 
+	m_flHorizSpeed = flLength * m_flFlightSpeed;
+
+	// compute total distance to travel
+	float flTotalDistance = m_flFlightTime * m_flHorizSpeed;
+	flTotalDistance -= vecStartPosition.AsVector2D().DistTo( vecImpactPosition.AsVector2D() );
+	if ( flTotalDistance <= 0.0f )
+	{
+		InitInWorld( flLaunchTime, vecStartPosition, vecStartAngles, vecDirection, vecImpactPosition );
+		return;
+	}
+
+	// Setup initial parametric state.
+	m_flLaunchTime = flLaunchTime;
+	m_flWorldEnterTime = flTotalDistance / m_flHorizSpeed;
+	m_vecSkyboxOrigin = vecSkyboxOrigin;
+	m_flSkyboxScale = flSkyboxScale;
+
+	m_vecEnterWorldPosition = vecStartPosition;
+	m_vecDirection = vecDirection;
+	m_vecStartAngles = vecStartAngles;
+	m_bInSkybox = true;
+	m_bLaunchedFromWithinWorld = false;
+
+	// Compute parabolic course
+	// Assume the x velocity remains constant.
+	// Z moves ballistically, as if under gravity
+	// zf + lh = zo
+	// vf = vo + a*t
+	// zf = zo + vo*t + 0.5 * a * t*t
+	// a*t = vf - vo
+	// zf = zo + vo*t + 0.5f * (vf - vo) * t
+	// zf - zo = 0.5f *vo*t + 0.5f * vf * t
+	// -lh - 0.5f * vf * t = 0.5f * vo * t
+	// vo = -2.0f * lh / t - vf
+	// a = (vf - vo) / t
+	m_flHorizSpeed /= flSkyboxScale;
+
+	VectorMA( vecSkyboxOrigin, 1.0f / m_flSkyboxScale, vecStartPosition, m_vecStartPosition.GetForModify() );
+	VectorMA( m_vecStartPosition.Get(), -m_flHorizSpeed * m_flWorldEnterTime, m_vecParabolaDirection, m_vecStartPosition.GetForModify() );
+
+	float flLaunchHeight = m_flLaunchHeight / flSkyboxScale;
+	float flFinalZSpeed = m_vecDirection.Get().z * m_flFlightSpeed / flSkyboxScale;
+	m_vecStartPosition.GetForModify().z += flLaunchHeight;
+	m_flZAcceleration = 2.0f * ( flLaunchHeight + flFinalZSpeed * m_flWorldEnterTime ) / ( m_flWorldEnterTime * m_flWorldEnterTime );
+	m_flInitialZSpeed = flFinalZSpeed - m_flZAcceleration * m_flWorldEnterTime;
+}
+
+
+//-----------------------------------------------------------------------------
+// Convert from skybox to world
+//-----------------------------------------------------------------------------
+void CEnvHeadcrabCanisterShared::ConvertFromSkyboxToWorld()
+{
+	Assert( m_bInSkybox );
+	m_bInSkybox = false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns the time at which it enters the world
+//-----------------------------------------------------------------------------
+float CEnvHeadcrabCanisterShared::GetEnterWorldTime() const
+{
+	return m_flWorldEnterTime;
+}
+
+
+//-----------------------------------------------------------------------------
+// Did we impact?
+//-----------------------------------------------------------------------------
+bool CEnvHeadcrabCanisterShared::DidImpact( float flTime ) const
+{
+	return (flTime - m_flLaunchTime) >= m_flFlightTime;
+}
+
+
+//-----------------------------------------------------------------------------
+// Computes the position of the canister
+//-----------------------------------------------------------------------------
+void CEnvHeadcrabCanisterShared::GetPositionAtTime( float flTime, Vector &vecPosition, QAngle &vecAngles )
+{
+	float flDeltaTime = flTime - m_flLaunchTime;
+	if ( flDeltaTime > m_flFlightTime )
+	{
+		flDeltaTime = m_flFlightTime;
+	}
+
+	VMatrix initToWorld;
+	if ( m_bLaunchedFromWithinWorld || m_bInSkybox )
+	{
+		VectorMA( m_vecStartPosition, flDeltaTime * m_flHorizSpeed, m_vecParabolaDirection, vecPosition );
+		vecPosition.z += m_flInitialZSpeed * flDeltaTime + 0.5f * m_flZAcceleration * flDeltaTime * flDeltaTime;
+
+		Vector vecLeft;
+		CrossProduct( m_vecParabolaDirection, Vector( 0, 0, 1 ), vecLeft );
+
+		Vector vecForward;
+		VectorMultiply( m_vecParabolaDirection, -1.0f, vecForward );
+		vecForward.z = -(m_flInitialZSpeed + m_flZAcceleration * flDeltaTime) / m_flHorizSpeed;	// This is -dz/dx.
+		VectorNormalize( vecForward );
+
+		Vector vecUp;
+		CrossProduct( vecForward, vecLeft, vecUp );
+ 
+		initToWorld.SetBasisVectors( vecForward, vecLeft, vecUp );
+	}
+	else
+	{
+		flDeltaTime -= m_flWorldEnterTime;
+		Vector vecVelocity;
+		VectorMultiply( m_vecDirection, m_flFlightSpeed, vecVelocity );
+		VectorMA( m_vecEnterWorldPosition, flDeltaTime, vecVelocity, vecPosition );
+
+		MatrixFromAngles( m_vecStartAngles.Get(), initToWorld );
+	}
+
+	VMatrix rotation;
+	MatrixBuildRotationAboutAxis( rotation, Vector( 1, 0, 0 ), flDeltaTime * ROTATION_SPEED );
+
+	VMatrix newAngles;
+	MatrixMultiply( initToWorld, rotation, newAngles );
+	MatrixToAngles( newAngles, vecAngles );
+}
+
+
+//-----------------------------------------------------------------------------
+// Are we in the skybox?
+//-----------------------------------------------------------------------------
+bool CEnvHeadcrabCanisterShared::IsInSkybox( )
+{
+	// Check to see if we are always in the world!
+	return m_bInSkybox;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CEnvHeadcrabCanisterShared::CalcEnterTime( const Vector &vecTriggerMins, 
+											  const Vector &vecTriggerMaxs )
+{
+	/*
+#define HEADCRABCANISTER_TRIGGER_EPSILON	0.001f
+
+	// Initialize the enter/exit fractions.
+	float flEnterFrac = 0.0f;
+	float flExitFrac = 1.0f;
+
+	// Create an arbitrarily large end position.
+	Vector vecEndPosition;
+	VectorMA( m_vecStartPosition, 32000.0f, m_vecDirection, vecEndPosition );
+
+	float flFrac, flDistStart, flDistEnd;
+	for( int iAxis = 0; iAxis < 3; iAxis++ )
+	{
+		// Negative Axis
+		flDistStart = -m_vecStartPosition[iAxis] + vecTriggerMins[iAxis];
+		flDistEnd = -vecEndPosition[iAxis] + vecTriggerMins[iAxis];
+
+		if ( ( flDistStart > 0.0f ) && ( flDistEnd < 0.0f ) ) 
+		{ 
+			flFrac = ( flDistStart - HEADCRABCANISTER_TRIGGER_EPSILON ) / ( flDistStart - flDistEnd );
+			if ( flFrac > flEnterFrac ) { flEnterFrac = flFrac; }
+		}
+
+		if ( ( flDistStart < 0.0f ) && ( flDistEnd > 0.0f ) ) 
+		{ 
+			flFrac = ( flDistStart + HEADCRABCANISTER_TRIGGER_EPSILON ) / ( flDistStart - flDistEnd );
+			if( flFrac < flExitFrac ) { flExitFrac = flFrac; }
+		}
+
+		if ( ( flDistStart > 0.0f ) && ( flDistEnd > 0.0f ) )
+			return;
+
+		// Positive Axis
+		flDistStart = m_vecStartPosition[iAxis] - vecTriggerMaxs[iAxis];
+		flDistEnd = vecEndPosition[iAxis] - vecTriggerMaxs[iAxis];
+
+		if ( ( flDistStart > 0.0f ) && ( flDistEnd < 0.0f ) ) 
+		{ 
+			flFrac = ( flDistStart - HEADCRABCANISTER_TRIGGER_EPSILON ) / ( flDistStart - flDistEnd );
+			if ( flFrac > flEnterFrac ) { flEnterFrac = flFrac; }
+		}
+
+		if ( ( flDistStart < 0.0f ) && ( flDistEnd > 0.0f ) ) 
+		{ 
+			flFrac = ( flDistStart + HEADCRABCANISTER_TRIGGER_EPSILON ) / ( flDistStart - flDistEnd );
+			if( flFrac < flExitFrac ) { flExitFrac = flFrac; }
+		}
+
+		if ( ( flDistStart > 0.0f ) && ( flDistEnd > 0.0f ) )
+			return;
+	}
+
+	// Check for intersection.
+	if ( flExitFrac >= flEnterFrac )
+	{
+		// Check to see if we start in the world or the skybox!
+		if ( flEnterFrac == 0.0f )
+		{
+			m_nLocation = HEADCRABCANISTER_LOCATION_WORLD;
+		}
+		else
+		{
+			m_nLocation = HEADCRABCANISTER_LOCATION_SKYBOX;
+		}
+
+		// Calculate the enter/exit times.
+		Vector vecEnterPoint, vecExitPoint, vecDeltaPosition;
+		VectorSubtract( vecEndPosition, m_vecStartPosition, vecDeltaPosition );
+		VectorScale( vecDeltaPosition, flEnterFrac, vecEnterPoint );
+		VectorScale( vecDeltaPosition, flExitFrac, vecExitPoint );
+
+		m_flWorldEnterTime = vecEnterPoint.Length() / m_flFlightSpeed;
+		m_flWorldEnterTime += m_flLaunchTime;
+	}
+	*/
+
+#undef HEADCRABCANISTER_TRIGGER_EPSILON
+}
+

game/shared/hl2/env_headcrabcanister_shared.h

@@ -0,0 +1,180 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef ENV_HEADCRABCANISTER_SHARED_H
+#define ENV_HEADCRABCANISTER_SHARED_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "vstdlib/random.h"
+#include "mathlib/vector.h"
+#include "utlvector.h"
+#include "networkvar.h"
+
+//=============================================================================
+//
+// Shared HeadcrabCanister Class
+//
+class CEnvHeadcrabCanisterShared
+{
+	DECLARE_CLASS_NOBASE( CEnvHeadcrabCanisterShared );
+	DECLARE_EMBEDDED_NETWORKVAR();
+	DECLARE_SIMPLE_DATADESC();
+
+public:
+	CEnvHeadcrabCanisterShared();
+
+	// Initialization.
+	void InitInWorld( float flLaunchTime, const Vector &vecStartPosition, const QAngle &vecStartAngles, const Vector &vecDirection, const Vector &vecImpactPosition, bool bLaunchedFromWithinWorld = false );
+	void InitInSkybox( float flLaunchTime, const Vector &vecStartPosition, const QAngle &vecStartAngles, const Vector &vecDirection, const Vector &vecImpactPosition, const Vector &vecSkyboxOrigin, float flSkyboxScale );
+
+	// Returns the position of the object at a given time.
+	void GetPositionAtTime( float flTime, Vector &vecPosition, QAngle &vecAngles );
+
+	// Returns whether or not the object is the the skybox
+	bool IsInSkybox( );
+
+	// Returns the time at which it enters the world
+	float GetEnterWorldTime() const;
+
+	// Convert from skybox to world
+	void ConvertFromSkyboxToWorld();
+
+	// Did we impact?
+	bool DidImpact( float flTime ) const;
+
+public:
+	// The objects initial parametric conditions.
+	CNetworkVector(	m_vecStartPosition );
+	CNetworkVector(	m_vecEnterWorldPosition );
+	CNetworkVector(	m_vecDirection );	
+	CNetworkQAngle( m_vecStartAngles );
+
+	CNetworkVar( float,	m_flFlightTime );
+	CNetworkVar( float,	m_flFlightSpeed );
+	CNetworkVar( float,	m_flLaunchTime );
+
+	CNetworkVar( float, m_flInitialZSpeed );
+	CNetworkVar( float, m_flZAcceleration );
+	CNetworkVar( float, m_flHorizSpeed );
+
+	CNetworkVar( bool, m_bLaunchedFromWithinWorld );
+
+	CNetworkVector( m_vecParabolaDirection );
+
+	// The time at which the canister enters the skybox
+	CNetworkVar( float,	m_flWorldEnterTime );
+
+	// Skybox data
+	CNetworkVector(	m_vecSkyboxOrigin );
+	CNetworkVar( float, m_flSkyboxScale );
+	CNetworkVar( bool, m_bInSkybox );
+
+private:
+	float	m_flLaunchHeight;
+
+	// Calculate the enter time. (called from Init)
+	void CalcEnterTime( const Vector &vecTriggerMins, const Vector &vecTriggerMaxs );			
+
+	friend class CEnvHeadcrabCanister;
+	friend class C_EnvHeadcrabCanister;
+};
+
+/*
+//=============================================================================
+//
+// HeadcrabCanister Factory Interface
+//
+abstract_class IHeadcrabCanisterFactory
+{
+public:
+
+	virtual void CreateHeadcrabCanister( int nID, int iType, 
+		                       const Vector &vecPosition, const Vector &vecDirection, 
+		                       float flSpeed, float flStartTime, float flDamageRadius,
+							   const Vector &vecTriggerMins, const Vector &vecTriggerMaxs ) = 0;
+};
+
+//=============================================================================
+//
+// Shared HeadcrabCanister Spawner Class
+//
+class CEnvHeadcrabCanisterSpawnerShared
+{
+public:
+	DECLARE_CLASS_NOBASE( CEnvHeadcrabCanisterSpawnerShared );
+	DECLARE_EMBEDDED_NETWORKVAR();
+
+	//-------------------------------------------------------------------------
+	// Initialization.
+	//-------------------------------------------------------------------------
+	CEnvHeadcrabCanisterSpawnerShared();
+	void	Init( IHeadcrabCanisterFactory *pFactory, int nRandomSeed, float flTime,
+				  const Vector &vecMinBounds, const Vector &vecMaxBounds,
+				  const Vector &vecTriggerMins, const Vector &vecTriggerMaxs );
+
+	//-------------------------------------------------------------------------
+	// Method to generate HeadcrabCanisters. 
+	// Time passed in here is global time, not delta time.
+	// The function returns the time at which it must be called again.
+	//-------------------------------------------------------------------------
+	float	HeadcrabCanisterThink( float flTime );
+
+	//-------------------------------------------------------------------------
+	// Add HeadcrabCanister target data, used to determine HeadcrabCanister travel direction.
+	//-------------------------------------------------------------------------
+	void	AddToTargetList( const Vector &vecPosition, float flRadius );
+
+	// Debugging!
+	int		GetRandomInt( int nMin, int nMax );
+	float	GetRandomFloat( float flMin, float flMax );
+
+public:
+
+	// Factory.
+	IHeadcrabCanisterFactory					*m_pFactory;			// HeadcrabCanister creation factory.
+
+	int								m_nHeadcrabCanisterCount;			// Number of HeadcrabCanisters created - used as IDs
+
+	// Initial spawner data.
+	CNetworkVar( float, m_flStartTime );			// Start time.
+	CNetworkVar( int, m_nRandomSeed );			// The random number stream seed.
+
+	CNetworkVar( int, m_iHeadcrabCanisterType );			// Type of HeadcrabCanister.
+	float							m_flHeadcrabCanisterDamageRadius;	// HeadcrabCanister damage radius.
+	CNetworkVar( bool, m_bSkybox );				// Is the spawner in the skybox?
+
+	CNetworkVar( float, m_flMinSpawnTime );		// Spawn time - Min
+	CNetworkVar( float, m_flMaxSpawnTime );		//              Max
+	CNetworkVar( int, m_nMinSpawnCount );		// Number of HeadcrabCanisters to spawn - Min
+	CNetworkVar( int, m_nMaxSpawnCount );		//							    Max
+	CNetworkVector( m_vecMinBounds );			// Spawner volume (space) - Min
+	CNetworkVector( m_vecMaxBounds );			//                          Max
+	CNetworkVar( float, m_flMinSpeed );			// HeadcrabCanister speed - Min
+	CNetworkVar( float, m_flMaxSpeed );			//                Max
+	CNetworkVector( m_vecTriggerMins );		// World Bounds (Trigger) in 3D Skybox - Min
+	CNetworkVector( m_vecTriggerMaxs );		//                                       Max
+	Vector							m_vecTriggerCenter;
+
+	// Generated data.
+	int								m_nRandomCallCount;		// Debug! Keep track of number steam calls.
+	float							m_flNextSpawnTime;		// Next HeadcrabCanister spawn time (random).
+	CUniformRandomStream			m_NumberStream;			// Used to generate random numbers.	
+
+	// Use "Targets" to determine HeadcrabCanister direction(s).
+	struct HeadcrabCanistertarget_t
+	{
+		Vector		m_vecPosition;
+		float		m_flRadius;
+	};
+	CUtlVector<HeadcrabCanistertarget_t>	m_aTargets;
+};
+*/
+
+#endif // ENV_HEADCRAB_CANISTER_SHARED_H

game/shared/hl2/hl2_gamerules.h

@@ -0,0 +1,118 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Game rules for Half-Life 2.
+//
+//=============================================================================//
+
+#ifndef HL2_GAMERULES_H
+#define HL2_GAMERULES_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "gamerules.h"
+#include "singleplay_gamerules.h"
+#include "hl2_shareddefs.h"
+
+#ifdef CLIENT_DLL
+	#define CHalfLife2 C_HalfLife2
+	#define CHalfLife2Proxy C_HalfLife2Proxy
+#endif
+
+
+class CHalfLife2Proxy : public CGameRulesProxy
+{
+public:
+	DECLARE_CLASS( CHalfLife2Proxy, CGameRulesProxy );
+	DECLARE_NETWORKCLASS();
+};
+
+
+class CHalfLife2 : public CSingleplayRules
+{
+public:
+	DECLARE_CLASS( CHalfLife2, CSingleplayRules );
+
+	// Damage Query Overrides.
+	virtual bool			Damage_IsTimeBased( int iDmgType );
+	// TEMP:
+	virtual int				Damage_GetTimeBased( void );
+	
+	virtual bool			ShouldCollide( int collisionGroup0, int collisionGroup1 );
+	virtual bool			ShouldUseRobustRadiusDamage(CBaseEntity *pEntity);
+#ifndef CLIENT_DLL
+	virtual bool			ShouldAutoAim( CBasePlayer *pPlayer, edict_t *target );
+	virtual float			GetAutoAimScale( CBasePlayer *pPlayer );
+	virtual float			GetAmmoQuantityScale( int iAmmoIndex );
+	virtual void			LevelInitPreEntity();
+#endif
+
+private:
+	// Rules change for the mega physgun
+	CNetworkVar( bool, m_bMegaPhysgun );
+
+#ifdef CLIENT_DLL
+
+	DECLARE_CLIENTCLASS_NOBASE(); // This makes datatables able to access our private vars.
+
+#else
+
+	DECLARE_SERVERCLASS_NOBASE(); // This makes datatables able to access our private vars.
+
+	CHalfLife2();
+	virtual ~CHalfLife2() {}
+
+	virtual void			Think( void );
+
+	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 ) { return "Half-Life 2"; }
+
+	// Ammo
+	virtual void			PlayerThink( CBasePlayer *pPlayer );
+	virtual float			GetAmmoDamage( CBaseEntity *pAttacker, CBaseEntity *pVictim, int nAmmoType );
+
+	virtual bool			ShouldBurningPropsEmitLight();
+public:
+
+	bool AllowDamage( CBaseEntity *pVictim, const CTakeDamageInfo &info );
+
+	bool	NPC_ShouldDropGrenade( CBasePlayer *pRecipient );
+	bool	NPC_ShouldDropHealth( CBasePlayer *pRecipient );
+	void	NPC_DroppedHealth( void );
+	void	NPC_DroppedGrenade( void );
+	bool	MegaPhyscannonActive( void ) { return m_bMegaPhysgun;	}
+	
+	virtual bool IsAlyxInDarknessMode();
+
+private:
+
+	float	m_flLastHealthDropTime;
+	float	m_flLastGrenadeDropTime;
+
+	void AdjustPlayerDamageTaken( CTakeDamageInfo *pInfo );
+	float AdjustPlayerDamageInflicted( float damage );
+
+	int						DefaultFOV( void ) { return 75; }
+#endif
+};
+
+
+//-----------------------------------------------------------------------------
+// Gets us at the Half-Life 2 game rules
+//-----------------------------------------------------------------------------
+inline CHalfLife2* HL2GameRules()
+{
+#if ( !defined( HL2_DLL ) && !defined( HL2_CLIENT_DLL ) ) || defined( HL2MP )
+	Assert( 0 );	// g_pGameRules is NOT an instance of CHalfLife2 and bad things happen
+#endif
+
+	return static_cast<CHalfLife2*>(g_pGameRules);
+}
+
+
+
+#endif // HL2_GAMERULES_H

game/shared/hl2/hl2_player_shared.h

@@ -0,0 +1,21 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef HL2_PLAYER_SHARED_H
+#define HL2_PLAYER_SHARED_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+// Shared header file for players
+#if defined( CLIENT_DLL )
+#define CHL2_Player C_BaseHLPlayer	//FIXME: Lovely naming job between server and client here...
+#include "c_basehlplayer.h"
+#else
+#include "hl2_player.h"
+#endif
+
+#endif // HL2_PLAYER_SHARED_H

game/shared/hl2/hl2_shareddefs.h

@@ -0,0 +1,49 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef HL2_SHAREDDEFS_H
+#define HL2_SHAREDDEFS_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "const.h"
+
+
+//--------------------------------------------------------------------------
+// Collision groups
+//--------------------------------------------------------------------------
+
+enum
+{
+	HL2COLLISION_GROUP_PLASMANODE = LAST_SHARED_COLLISION_GROUP,
+	HL2COLLISION_GROUP_SPIT,
+	HL2COLLISION_GROUP_HOMING_MISSILE,
+	HL2COLLISION_GROUP_COMBINE_BALL,
+
+	HL2COLLISION_GROUP_FIRST_NPC,
+	HL2COLLISION_GROUP_HOUNDEYE,
+	HL2COLLISION_GROUP_CROW,
+	HL2COLLISION_GROUP_HEADCRAB,
+	HL2COLLISION_GROUP_STRIDER,
+	HL2COLLISION_GROUP_GUNSHIP,
+	HL2COLLISION_GROUP_ANTLION,
+	HL2COLLISION_GROUP_LAST_NPC,
+	HL2COLLISION_GROUP_COMBINE_BALL_NPC,
+};
+
+
+//--------------
+// HL2 SPECIFIC
+//--------------
+#define DMG_SNIPER			(DMG_LASTGENERICFLAG<<1)	// This is sniper damage
+#define DMG_MISSILEDEFENSE	(DMG_LASTGENERICFLAG<<2)	// The only kind of damage missiles take. (special missile defense)
+
+
+
+#endif // HL2_SHAREDDEFS_H

game/shared/hl2/hl2_usermessages.cpp

@@ -0,0 +1,53 @@
+//========= 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"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.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 );		// BUG: floats are sent for coords, no variable bitfields in hud & fixed size Msg
+	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( "SquadMemberDied", 0 );
+	usermessages->Register( "AmmoDenied", 2 );
+	usermessages->Register( "CreditsMsg", 1 );
+	usermessages->Register( "LogoTimeMsg", 4 );
+	usermessages->Register( "AchievementEvent", -1 );
+	usermessages->Register( "UpdateJalopyRadar", -1 );
+
+#ifndef _X360
+	// NVNT register haptic user messages
+	RegisterHapticMessages();
+#endif
+}

game/shared/hl2/hl2_vehicle_radar.h

@@ -0,0 +1,27 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+#ifndef HL2_VEHICLE_RADAR_H
+#define HL2_VEHICLE_RADAR_H
+
+#define RADAR_MAX_CONTACTS			24
+#define RADAR_CONTACT_TYPE_BITS		3	// Max 8 types of contacts (for networking)
+#define RADAR_UPDATE_FREQUENCY		1.5f
+#define RADAR_UPDATE_FREQUENCY_FAST	0.5f
+
+enum // If we have more than 16 types of contacts, RADAR_CONTACT_TYPE_BITS
+{
+	RADAR_CONTACT_NONE = -1,
+	RADAR_CONTACT_GENERIC = 0,
+	RADAR_CONTACT_MAGNUSSEN_RDU,
+	RADAR_CONTACT_DOG,
+	RADAR_CONTACT_ALLY_INSTALLATION,
+	RADAR_CONTACT_ENEMY,			// 'regular' sized enemy (Hunter)
+	RADAR_CONTACT_LARGE_ENEMY,		// Large enemy (Strider)
+};
+
+#endif

game/shared/hl2/hl_gamemovement.h

@@ -0,0 +1,129 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Special handling for hl2 usable ladders
+//
+//=============================================================================//
+
+#include "gamemovement.h"
+#include "func_ladder.h"
+
+#if defined( CLIENT_DLL )
+
+#include "c_basehlplayer.h"
+#define CHL2_Player C_BaseHLPlayer
+#else
+
+#include "hl2_player.h"
+
+#endif
+
+struct LadderMove_t;
+class CInfoLadderDismount;
+
+struct NearbyDismount_t
+{
+	CInfoLadderDismount		*dismount;
+	float					distSqr;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: HL2 specific movement code
+//-----------------------------------------------------------------------------
+class CHL2GameMovement : public CGameMovement
+{
+	typedef CGameMovement BaseClass;
+public:
+
+	CHL2GameMovement();
+
+// Overrides
+	virtual void FullLadderMove();
+	virtual bool LadderMove( void );
+	virtual bool OnLadder( trace_t &trace );
+	virtual int GetCheckInterval( IntervalType_t type );
+	virtual void	SetGroundEntity( trace_t *pm );
+	virtual bool CanAccelerate( void );
+
+private:
+
+	// See if we are pressing use near a ladder "mount" point and if so, latch us onto the ladder
+	bool		CheckLadderAutoMount( CFuncLadder *ladder, const Vector& bestOrigin );
+
+	bool		CheckLadderAutoMountCone( CFuncLadder *ladder, const Vector& bestOrigin, float maxAngleDelta, float maxDistToLadder );
+	bool		CheckLadderAutoMountEndPoint(CFuncLadder *ladder, const Vector& bestOrigin );
+
+
+	bool		LookingAtLadder( CFuncLadder *ladder );
+
+	// Are we forcing the user's position to a new spot
+	bool		IsForceMoveActive();
+	// Start forcing player position
+	void		StartForcedMove( bool mounting, float transit_speed, const Vector& goalpos, CFuncLadder *ladder );
+	// Returns false when finished
+	bool		ContinueForcedMove();
+
+	// Given a list of nearby ladders, find the best ladder and the "mount" origin
+	void		Findladder( float maxdist, CFuncLadder **ppLadder, Vector& ladderOrigin, const CFuncLadder *skipLadder );
+
+	// Debounce the +USE key
+	void		SwallowUseKey();
+
+	// Returns true if the player will auto-exit the ladder via a dismount node
+	bool		ExitLadderViaDismountNode( CFuncLadder *ladder, bool strict, bool useAlternate = false );
+	void		GetSortedDismountNodeList( const Vector &org, float radius, CFuncLadder *ladder, CUtlRBTree< NearbyDismount_t, int >& list );
+
+	LadderMove_t *GetLadderMove();
+	CHL2_Player	*GetHL2Player();
+
+	void		SetLadder( CFuncLadder *ladder );
+	CFuncLadder *GetLadder();
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+inline CHL2_Player	*CHL2GameMovement::GetHL2Player()
+{
+	return static_cast< CHL2_Player * >( player );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : inline LadderMove*
+//-----------------------------------------------------------------------------
+inline LadderMove_t *CHL2GameMovement::GetLadderMove()
+{
+	CHL2_Player *p = GetHL2Player();
+	if ( !p )
+	{
+		return NULL;
+	}
+	return p->GetLadderMove();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *ladder - 
+//-----------------------------------------------------------------------------
+inline void CHL2GameMovement::SetLadder( CFuncLadder *ladder )
+{
+	CFuncLadder* oldLadder = GetLadder();
+
+	if ( !ladder && oldLadder )
+	{
+		oldLadder->PlayerGotOff( GetHL2Player() );
+	}
+
+
+	GetHL2Player()->m_HL2Local.m_hLadder.Set( ladder );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : CFuncLadder
+//-----------------------------------------------------------------------------
+inline CFuncLadder *CHL2GameMovement::GetLadder()
+{
+	return static_cast<CFuncLadder*>( static_cast<CBaseEntity *>( GetHL2Player()->m_HL2Local.m_hLadder.Get() ) );
+}

game/shared/hl2/hl_movedata.h

@@ -0,0 +1,51 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef HL_MOVEDATA_H
+#define HL_MOVEDATA_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "igamemovement.h"
+
+
+// This class contains HL2-specific prediction data.
+class CHLMoveData : public CMoveData
+{
+public:
+	bool		m_bIsSprinting;
+};
+
+class CFuncLadder;
+class CReservePlayerSpot;
+
+//-----------------------------------------------------------------------------
+// Purpose: Data related to automatic mounting/dismounting from ladders
+//-----------------------------------------------------------------------------
+struct LadderMove_t
+{
+	DECLARE_SIMPLE_DATADESC();
+
+	//	Are we forcing player movement during mount/dismount
+	bool		m_bForceLadderMove;
+	// Is the forced move getting on or off the ladder
+	bool		m_bForceMount;
+	
+	// Simulation info for forcing the player move
+	float		m_flStartTime;
+	float		m_flArrivalTime;
+	Vector		m_vecGoalPosition;
+	Vector		m_vecStartPosition;
+
+	// The ladder entity owning the forced move (for marking us "on" the ladder after automounting it)
+	CHandle< CFuncLadder > m_hForceLadder;
+	CHandle< CReservePlayerSpot > m_hReservedSpot;
+};
+
+#endif // HL_MOVEDATA_H

game/shared/hl2/survival_gamerules.cpp

@@ -0,0 +1,273 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+#include "cbase.h"
+
+#ifdef HL2_EPISODIC
+
+#include "hl2_gamerules.h"
+#include "ammodef.h"
+#include "hl2_shareddefs.h"
+#include "filesystem.h"
+#include <KeyValues.h>
+
+#ifdef CLIENT_DLL
+
+#else
+#include "player.h"
+#include "game.h"
+#include "gamerules.h"
+#include "teamplay_gamerules.h"
+#include "hl2_player.h"
+#include "voice_gamemgr.h"
+#include "globalstate.h"
+#include "ai_basenpc.h"
+#include "weapon_physcannon.h"
+#include "ammodef.h"
+#endif
+
+#ifdef CLIENT_DLL
+#define CHalfLife2Survival C_HalfLife2Survival
+#define CHalfLife2SurvivalProxy C_HalfLife2SurvivalProxy
+#endif
+
+ConVar gamerules_survival( "gamerules_survival", "0", FCVAR_REPLICATED );
+
+class CHalfLife2SurvivalProxy : public CGameRulesProxy
+{
+public:
+	DECLARE_CLASS( CHalfLife2SurvivalProxy, CGameRulesProxy );
+	DECLARE_NETWORKCLASS();
+};
+
+class CSurvivalAmmo
+{
+public:
+
+	char	m_szAmmoName[256];
+	int		m_iAmount;
+};
+
+class CSurvivalSettings
+{
+public:
+
+	CSurvivalSettings();
+
+	CUtlVector<char*, CUtlMemory<char*> > m_Loadout;
+	int		 m_iSpawnHealth;
+	string_t m_szPickups;
+	CUtlVector<CSurvivalAmmo> m_Ammo;
+};
+
+CSurvivalSettings::CSurvivalSettings()
+{
+	m_iSpawnHealth = 100;
+}
+
+class CHalfLife2Survival : public CHalfLife2
+{
+public:
+	DECLARE_CLASS( CHalfLife2Survival, CHalfLife2 );
+
+#ifdef CLIENT_DLL
+
+	DECLARE_CLIENTCLASS_NOBASE(); // This makes datatables able to access our private vars.
+
+#else
+
+	DECLARE_SERVERCLASS_NOBASE(); // This makes datatables able to access our private vars.
+
+	CHalfLife2Survival();
+	virtual ~CHalfLife2Survival() {}
+
+	virtual void Think( void );
+	virtual void PlayerSpawn( CBasePlayer *pPlayer );
+	virtual bool IsAllowedToSpawn( CBaseEntity *pEntity );
+	virtual void CreateStandardEntities();
+
+	void	ReadSurvivalScriptFile( void );
+	void	ParseSurvivalSettings( KeyValues *pSubKey );
+	void	ParseSurvivalAmmo( KeyValues *pSubKey );
+
+private:
+	bool			  m_bActive;
+	CSurvivalSettings m_SurvivalSettings;
+#endif
+
+};
+
+//-----------------------------------------------------------------------------
+// Gets us at the Half-Life 2 game rules
+//-----------------------------------------------------------------------------
+inline CHalfLife2Survival* HL2SurvivalGameRules()
+{
+	return static_cast<CHalfLife2Survival*>(g_pGameRules);
+}
+
+REGISTER_GAMERULES_CLASS( CHalfLife2Survival );
+
+BEGIN_NETWORK_TABLE_NOBASE( CHalfLife2Survival, DT_HL2SurvivalGameRules )
+END_NETWORK_TABLE()
+
+
+LINK_ENTITY_TO_CLASS( hl2_survival_gamerules, CHalfLife2SurvivalProxy );
+IMPLEMENT_NETWORKCLASS_ALIASED( HalfLife2SurvivalProxy, DT_HalfLife2SurvivalProxy )
+
+#ifdef CLIENT_DLL
+	void RecvProxy_HL2SurvivalGameRules( const RecvProp *pProp, void **pOut, void *pData, int objectID )
+	{
+		CHalfLife2Survival *pRules = HL2SurvivalGameRules();
+		Assert( pRules );
+		*pOut = pRules;
+	}
+
+	BEGIN_RECV_TABLE( CHalfLife2SurvivalProxy, DT_HalfLife2SurvivalProxy )
+	RecvPropDataTable( "hl2_survival_gamerules_data", 0, 0, &REFERENCE_RECV_TABLE( DT_HL2SurvivalGameRules ), RecvProxy_HL2SurvivalGameRules )
+	END_RECV_TABLE()
+	#else
+	void* SendProxy_HL2SurvivalGameRules( const SendProp *pProp, const void *pStructBase, const void *pData, CSendProxyRecipients *pRecipients, int objectID )
+	{
+		CHalfLife2Survival *pRules = HL2SurvivalGameRules();
+		Assert( pRules );
+		pRecipients->SetAllRecipients();
+		return pRules;
+	}
+
+	BEGIN_SEND_TABLE( CHalfLife2SurvivalProxy, DT_HalfLife2SurvivalProxy )
+	SendPropDataTable( "hl2_survival_gamerules_data", 0, &REFERENCE_SEND_TABLE( DT_HL2SurvivalGameRules ), SendProxy_HL2SurvivalGameRules )
+	END_SEND_TABLE()
+#endif
+
+#ifndef CLIENT_DLL
+
+CHalfLife2Survival::CHalfLife2Survival()
+{
+	m_bActive = false;
+}
+
+void CHalfLife2Survival::Think( void )
+{
+
+}
+
+bool CHalfLife2Survival::IsAllowedToSpawn( CBaseEntity *pEntity )
+{
+	if ( !m_bActive )
+		return BaseClass::IsAllowedToSpawn( pEntity );
+
+	const char *pPickups = STRING( m_SurvivalSettings.m_szPickups );
+	if ( !pPickups )
+		return false;
+
+	if ( Q_stristr( pPickups, "everything" ) )
+		return true;
+
+	if ( Q_stristr( pPickups, pEntity->GetClassname() ) ||  Q_stristr( pPickups, STRING( pEntity->GetEntityName() ) ) )
+		return true;
+
+	return false;
+}
+
+void CHalfLife2Survival::PlayerSpawn( CBasePlayer *pPlayer )
+{
+	BaseClass::PlayerSpawn( pPlayer );
+
+	if ( !m_bActive )
+		return;
+
+	pPlayer->EquipSuit();
+	pPlayer->SetHealth( m_SurvivalSettings.m_iSpawnHealth );
+
+	for ( int i = 0; i < m_SurvivalSettings.m_Loadout.Count(); ++i )
+	{
+		pPlayer->GiveNamedItem( m_SurvivalSettings.m_Loadout[i] );
+	}
+
+	for ( int i = 0; i < m_SurvivalSettings.m_Ammo.Count(); ++i )
+	{
+		pPlayer->CBasePlayer::GiveAmmo( m_SurvivalSettings.m_Ammo[i].m_iAmount , m_SurvivalSettings.m_Ammo[i].m_szAmmoName );
+	}
+}
+
+void CHalfLife2Survival::ParseSurvivalSettings( KeyValues *pSubKey )
+{
+	if ( pSubKey == NULL )
+		return;
+
+	m_SurvivalSettings.m_szPickups = NULL_STRING;
+	m_SurvivalSettings.m_iSpawnHealth = 100;
+
+	KeyValues *pTestKey = pSubKey->GetFirstSubKey();
+
+	while ( pTestKey )
+	{
+		if ( !stricmp( pTestKey->GetName(), "weapons" ) )
+		{
+			const char *pLoadout =  pTestKey->GetString();
+			Q_SplitString( pLoadout, ";", m_SurvivalSettings.m_Loadout );
+		}
+		else if ( !stricmp( pTestKey->GetName(), "spawnhealth" ) )
+		{
+			m_SurvivalSettings.m_iSpawnHealth = pTestKey->GetInt( NULL, 100 );
+		}
+		else if ( !stricmp( pTestKey->GetName(), "allowedpickups" ) )
+		{
+			m_SurvivalSettings.m_szPickups = MAKE_STRING( pTestKey->GetString() );
+		}
+		
+		pTestKey = pTestKey->GetNextKey();
+	}
+}
+
+void CHalfLife2Survival::ParseSurvivalAmmo( KeyValues *pSubKey )
+{
+	if ( pSubKey )
+	{
+		KeyValues *pAmmoKey = pSubKey->GetFirstSubKey();
+
+		while ( pAmmoKey )
+		{
+			CSurvivalAmmo ammo;
+
+			Q_strcpy( ammo.m_szAmmoName, pAmmoKey->GetName() );
+			ammo.m_iAmount = pAmmoKey->GetInt();
+
+			m_SurvivalSettings.m_Ammo.AddToTail( ammo );
+
+			pAmmoKey = pAmmoKey->GetNextKey();
+		}
+	}
+}
+
+void CHalfLife2Survival::ReadSurvivalScriptFile( void )
+{
+	char szFullName[512];
+	Q_snprintf( szFullName, sizeof( szFullName ), "maps/%s_survival.txt", STRING(gpGlobals->mapname) );
+
+	KeyValues *pkvFile = new KeyValues( "Survival" );
+	if ( pkvFile->LoadFromFile( filesystem, szFullName, "MOD" ) )
+	{
+		ParseSurvivalSettings( pkvFile->FindKey( "settings" ) );
+		ParseSurvivalAmmo( pkvFile->FindKey( "ammo" ) );
+
+		CUtlVector <CBaseEntity*> entities;
+		UTIL_LoadAndSpawnEntitiesFromScript( entities, szFullName, "Survival", true );
+
+		// It's important to turn on survival mode after we create all the entities
+		// in the script, so that we don't remove them if they violate survival rules.
+		// i.e. we want the player to start with a shotgun, but prevent all future shotguns from spawning.
+		m_bActive = true;
+	}
+	else
+	{
+		m_bActive = false;
+	}
+}
+
+void CHalfLife2Survival::CreateStandardEntities( void )
+{
+	ReadSurvivalScriptFile();
+}
+
+#endif
+
+#endif