First version of the SOurce SDK 2013

1 files changed, 1629 insertions, 0 deletions

diff --git a/mp/src/game/server/hl2mp/hl2mp_player.cpp b/mp/src/game/server/hl2mp/hl2mp_player.cpp
new file mode 100644
index 00000000..fa828031
--- /dev/null
+++ b/mp/src/game/server/hl2mp/hl2mp_player.cpp
@@ -0,0 +1,1629 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//

+//

+// Purpose:		Player for HL2.

+//

+//=============================================================================//

+

+#include "cbase.h"

+#include "weapon_hl2mpbasehlmpcombatweapon.h"

+#include "hl2mp_player.h"

+#include "globalstate.h"

+#include "game.h"

+#include "gamerules.h"

+#include "hl2mp_player_shared.h"

+#include "predicted_viewmodel.h"

+#include "in_buttons.h"

+#include "hl2mp_gamerules.h"

+#include "KeyValues.h"

+#include "team.h"

+#include "weapon_hl2mpbase.h"

+#include "grenade_satchel.h"

+#include "eventqueue.h"

+#include "gamestats.h"

+

+#include "engine/IEngineSound.h"

+#include "SoundEmitterSystem/isoundemittersystembase.h"

+

+#include "ilagcompensationmanager.h"

+

+int g_iLastCitizenModel = 0;

+int g_iLastCombineModel = 0;

+

+CBaseEntity	 *g_pLastCombineSpawn = NULL;

+CBaseEntity	 *g_pLastRebelSpawn = NULL;

+extern CBaseEntity				*g_pLastSpawn;

+

+#define HL2MP_COMMAND_MAX_RATE 0.3

+

+void DropPrimedFragGrenade( CHL2MP_Player *pPlayer, CBaseCombatWeapon *pGrenade );

+

+LINK_ENTITY_TO_CLASS( player, CHL2MP_Player );

+

+LINK_ENTITY_TO_CLASS( info_player_combine, CPointEntity );

+LINK_ENTITY_TO_CLASS( info_player_rebel, CPointEntity );

+

+IMPLEMENT_SERVERCLASS_ST(CHL2MP_Player, DT_HL2MP_Player)

+	SendPropAngle( SENDINFO_VECTORELEM(m_angEyeAngles, 0), 11, SPROP_CHANGES_OFTEN ),

+	SendPropAngle( SENDINFO_VECTORELEM(m_angEyeAngles, 1), 11, SPROP_CHANGES_OFTEN ),

+	SendPropEHandle( SENDINFO( m_hRagdoll ) ),

+	SendPropInt( SENDINFO( m_iSpawnInterpCounter), 4 ),

+	SendPropInt( SENDINFO( m_iPlayerSoundType), 3 ),

+	

+	SendPropExclude( "DT_BaseAnimating", "m_flPoseParameter" ),

+	SendPropExclude( "DT_BaseFlex", "m_viewtarget" ),

+

+//	SendPropExclude( "DT_ServerAnimationData" , "m_flCycle" ),	

+//	SendPropExclude( "DT_AnimTimeMustBeFirst" , "m_flAnimTime" ),

+	

+END_SEND_TABLE()

+

+BEGIN_DATADESC( CHL2MP_Player )

+END_DATADESC()

+

+const char *g_ppszRandomCitizenModels[] = 

+{

+	"models/humans/group03/male_01.mdl",

+	"models/humans/group03/male_02.mdl",

+	"models/humans/group03/female_01.mdl",

+	"models/humans/group03/male_03.mdl",

+	"models/humans/group03/female_02.mdl",

+	"models/humans/group03/male_04.mdl",

+	"models/humans/group03/female_03.mdl",

+	"models/humans/group03/male_05.mdl",

+	"models/humans/group03/female_04.mdl",

+	"models/humans/group03/male_06.mdl",

+	"models/humans/group03/female_06.mdl",

+	"models/humans/group03/male_07.mdl",

+	"models/humans/group03/female_07.mdl",

+	"models/humans/group03/male_08.mdl",

+	"models/humans/group03/male_09.mdl",

+};

+

+const char *g_ppszRandomCombineModels[] =

+{

+	"models/combine_soldier.mdl",

+	"models/combine_soldier_prisonguard.mdl",

+	"models/combine_super_soldier.mdl",

+	"models/police.mdl",

+};

+

+

+#define MAX_COMBINE_MODELS 4

+#define MODEL_CHANGE_INTERVAL 5.0f

+#define TEAM_CHANGE_INTERVAL 5.0f

+

+#define HL2MPPLAYER_PHYSDAMAGE_SCALE 4.0f

+

+#pragma warning( disable : 4355 )

+

+CHL2MP_Player::CHL2MP_Player() : m_PlayerAnimState( this )

+{

+	m_angEyeAngles.Init();

+

+	m_iLastWeaponFireUsercmd = 0;

+

+	m_flNextModelChangeTime = 0.0f;

+	m_flNextTeamChangeTime = 0.0f;

+

+	m_iSpawnInterpCounter = 0;

+

+    m_bEnterObserver = false;

+	m_bReady = false;

+

+	BaseClass::ChangeTeam( 0 );

+	

+//	UseClientSideAnimation();

+}

+

+CHL2MP_Player::~CHL2MP_Player( void )

+{

+

+}

+

+void CHL2MP_Player::UpdateOnRemove( void )

+{

+	if ( m_hRagdoll )

+	{

+		UTIL_RemoveImmediate( m_hRagdoll );

+		m_hRagdoll = NULL;

+	}

+

+	BaseClass::UpdateOnRemove();

+}

+

+void CHL2MP_Player::Precache( void )

+{

+	BaseClass::Precache();

+

+	PrecacheModel ( "sprites/glow01.vmt" );

+

+	//Precache Citizen models

+	int nHeads = ARRAYSIZE( g_ppszRandomCitizenModels );

+	int i;	

+

+	for ( i = 0; i < nHeads; ++i )

+	   	 PrecacheModel( g_ppszRandomCitizenModels[i] );

+

+	//Precache Combine Models

+	nHeads = ARRAYSIZE( g_ppszRandomCombineModels );

+

+	for ( i = 0; i < nHeads; ++i )

+	   	 PrecacheModel( g_ppszRandomCombineModels[i] );

+

+	PrecacheFootStepSounds();

+

+	PrecacheScriptSound( "NPC_MetroPolice.Die" );

+	PrecacheScriptSound( "NPC_CombineS.Die" );

+	PrecacheScriptSound( "NPC_Citizen.die" );

+}

+

+void CHL2MP_Player::GiveAllItems( void )

+{

+	EquipSuit();

+

+	CBasePlayer::GiveAmmo( 255,	"Pistol");

+	CBasePlayer::GiveAmmo( 255,	"AR2" );

+	CBasePlayer::GiveAmmo( 5,	"AR2AltFire" );

+	CBasePlayer::GiveAmmo( 255,	"SMG1");

+	CBasePlayer::GiveAmmo( 1,	"smg1_grenade");

+	CBasePlayer::GiveAmmo( 255,	"Buckshot");

+	CBasePlayer::GiveAmmo( 32,	"357" );

+	CBasePlayer::GiveAmmo( 3,	"rpg_round");

+

+	CBasePlayer::GiveAmmo( 1,	"grenade" );

+	CBasePlayer::GiveAmmo( 2,	"slam" );

+

+	GiveNamedItem( "weapon_crowbar" );

+	GiveNamedItem( "weapon_stunstick" );

+	GiveNamedItem( "weapon_pistol" );

+	GiveNamedItem( "weapon_357" );

+

+	GiveNamedItem( "weapon_smg1" );

+	GiveNamedItem( "weapon_ar2" );

+	

+	GiveNamedItem( "weapon_shotgun" );

+	GiveNamedItem( "weapon_frag" );

+	

+	GiveNamedItem( "weapon_crossbow" );

+	

+	GiveNamedItem( "weapon_rpg" );

+

+	GiveNamedItem( "weapon_slam" );

+

+	GiveNamedItem( "weapon_physcannon" );

+	

+}

+

+void CHL2MP_Player::GiveDefaultItems( void )

+{

+	EquipSuit();

+

+	CBasePlayer::GiveAmmo( 255,	"Pistol");

+	CBasePlayer::GiveAmmo( 45,	"SMG1");

+	CBasePlayer::GiveAmmo( 1,	"grenade" );

+	CBasePlayer::GiveAmmo( 6,	"Buckshot");

+	CBasePlayer::GiveAmmo( 6,	"357" );

+

+	if ( GetPlayerModelType() == PLAYER_SOUNDS_METROPOLICE || GetPlayerModelType() == PLAYER_SOUNDS_COMBINESOLDIER )

+	{

+		GiveNamedItem( "weapon_stunstick" );

+	}

+	else if ( GetPlayerModelType() == PLAYER_SOUNDS_CITIZEN )

+	{

+		GiveNamedItem( "weapon_crowbar" );

+	}

+	

+	GiveNamedItem( "weapon_pistol" );

+	GiveNamedItem( "weapon_smg1" );

+	GiveNamedItem( "weapon_frag" );

+	GiveNamedItem( "weapon_physcannon" );

+

+	const char *szDefaultWeaponName = engine->GetClientConVarValue( engine->IndexOfEdict( edict() ), "cl_defaultweapon" );

+

+	CBaseCombatWeapon *pDefaultWeapon = Weapon_OwnsThisType( szDefaultWeaponName );

+

+	if ( pDefaultWeapon )

+	{

+		Weapon_Switch( pDefaultWeapon );

+	}

+	else

+	{

+		Weapon_Switch( Weapon_OwnsThisType( "weapon_physcannon" ) );

+	}

+}

+

+void CHL2MP_Player::PickDefaultSpawnTeam( void )

+{

+	if ( GetTeamNumber() == 0 )

+	{

+		if ( HL2MPRules()->IsTeamplay() == false )

+		{

+			if ( GetModelPtr() == NULL )

+			{

+				const char *szModelName = NULL;

+				szModelName = engine->GetClientConVarValue( engine->IndexOfEdict( edict() ), "cl_playermodel" );

+

+				if ( ValidatePlayerModel( szModelName ) == false )

+				{

+					char szReturnString[512];

+

+					Q_snprintf( szReturnString, sizeof (szReturnString ), "cl_playermodel models/combine_soldier.mdl\n" );

+					engine->ClientCommand ( edict(), szReturnString );

+				}

+

+				ChangeTeam( TEAM_UNASSIGNED );

+			}

+		}

+		else

+		{

+			CTeam *pCombine = g_Teams[TEAM_COMBINE];

+			CTeam *pRebels = g_Teams[TEAM_REBELS];

+

+			if ( pCombine == NULL || pRebels == NULL )

+			{

+				ChangeTeam( random->RandomInt( TEAM_COMBINE, TEAM_REBELS ) );

+			}

+			else

+			{

+				if ( pCombine->GetNumPlayers() > pRebels->GetNumPlayers() )

+				{

+					ChangeTeam( TEAM_REBELS );

+				}

+				else if ( pCombine->GetNumPlayers() < pRebels->GetNumPlayers() )

+				{

+					ChangeTeam( TEAM_COMBINE );

+				}

+				else

+				{

+					ChangeTeam( random->RandomInt( TEAM_COMBINE, TEAM_REBELS ) );

+				}

+			}

+		}

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Sets HL2 specific defaults.

+//-----------------------------------------------------------------------------

+void CHL2MP_Player::Spawn(void)

+{

+	m_flNextModelChangeTime = 0.0f;

+	m_flNextTeamChangeTime = 0.0f;

+

+	PickDefaultSpawnTeam();

+

+	BaseClass::Spawn();

+	

+	if ( !IsObserver() )

+	{

+		pl.deadflag = false;

+		RemoveSolidFlags( FSOLID_NOT_SOLID );

+

+		RemoveEffects( EF_NODRAW );

+		

+		GiveDefaultItems();

+	}

+

+	SetNumAnimOverlays( 3 );

+	ResetAnimation();

+

+	m_nRenderFX = kRenderNormal;

+

+	m_Local.m_iHideHUD = 0;

+	

+	AddFlag(FL_ONGROUND); // set the player on the ground at the start of the round.

+

+	m_impactEnergyScale = HL2MPPLAYER_PHYSDAMAGE_SCALE;

+

+	if ( HL2MPRules()->IsIntermission() )

+	{

+		AddFlag( FL_FROZEN );

+	}

+	else

+	{

+		RemoveFlag( FL_FROZEN );

+	}

+

+	m_iSpawnInterpCounter = (m_iSpawnInterpCounter + 1) % 8;

+

+	m_Local.m_bDucked = false;

+

+	SetPlayerUnderwater(false);

+

+	m_bReady = false;

+}

+

+void CHL2MP_Player::PickupObject( CBaseEntity *pObject, bool bLimitMassAndSize )

+{

+	

+}

+

+bool CHL2MP_Player::ValidatePlayerModel( const char *pModel )

+{

+	int iModels = ARRAYSIZE( g_ppszRandomCitizenModels );

+	int i;	

+

+	for ( i = 0; i < iModels; ++i )

+	{

+		if ( !Q_stricmp( g_ppszRandomCitizenModels[i], pModel ) )

+		{

+			return true;

+		}

+	}

+

+	iModels = ARRAYSIZE( g_ppszRandomCombineModels );

+

+	for ( i = 0; i < iModels; ++i )

+	{

+	   	if ( !Q_stricmp( g_ppszRandomCombineModels[i], pModel ) )

+		{

+			return true;

+		}

+	}

+

+	return false;

+}

+

+void CHL2MP_Player::SetPlayerTeamModel( void )

+{

+	const char *szModelName = NULL;

+	szModelName = engine->GetClientConVarValue( engine->IndexOfEdict( edict() ), "cl_playermodel" );

+

+	int modelIndex = modelinfo->GetModelIndex( szModelName );

+

+	if ( modelIndex == -1 || ValidatePlayerModel( szModelName ) == false )

+	{

+		szModelName = "models/Combine_Soldier.mdl";

+		m_iModelType = TEAM_COMBINE;

+

+		char szReturnString[512];

+

+		Q_snprintf( szReturnString, sizeof (szReturnString ), "cl_playermodel %s\n", szModelName );

+		engine->ClientCommand ( edict(), szReturnString );

+	}

+

+	if ( GetTeamNumber() == TEAM_COMBINE )

+	{

+		if ( Q_stristr( szModelName, "models/human") )

+		{

+			int nHeads = ARRAYSIZE( g_ppszRandomCombineModels );

+		

+			g_iLastCombineModel = ( g_iLastCombineModel + 1 ) % nHeads;

+			szModelName = g_ppszRandomCombineModels[g_iLastCombineModel];

+		}

+

+		m_iModelType = TEAM_COMBINE;

+	}

+	else if ( GetTeamNumber() == TEAM_REBELS )

+	{

+		if ( !Q_stristr( szModelName, "models/human") )

+		{

+			int nHeads = ARRAYSIZE( g_ppszRandomCitizenModels );

+

+			g_iLastCitizenModel = ( g_iLastCitizenModel + 1 ) % nHeads;

+			szModelName = g_ppszRandomCitizenModels[g_iLastCitizenModel];

+		}

+

+		m_iModelType = TEAM_REBELS;

+	}

+	

+	SetModel( szModelName );

+	SetupPlayerSoundsByModel( szModelName );

+

+	m_flNextModelChangeTime = gpGlobals->curtime + MODEL_CHANGE_INTERVAL;

+}

+

+void CHL2MP_Player::SetPlayerModel( void )

+{

+	const char *szModelName = NULL;

+	const char *pszCurrentModelName = modelinfo->GetModelName( GetModel());

+

+	szModelName = engine->GetClientConVarValue( engine->IndexOfEdict( edict() ), "cl_playermodel" );

+

+	if ( ValidatePlayerModel( szModelName ) == false )

+	{

+		char szReturnString[512];

+

+		if ( ValidatePlayerModel( pszCurrentModelName ) == false )

+		{

+			pszCurrentModelName = "models/Combine_Soldier.mdl";

+		}

+

+		Q_snprintf( szReturnString, sizeof (szReturnString ), "cl_playermodel %s\n", pszCurrentModelName );

+		engine->ClientCommand ( edict(), szReturnString );

+

+		szModelName = pszCurrentModelName;

+	}

+

+	if ( GetTeamNumber() == TEAM_COMBINE )

+	{

+		int nHeads = ARRAYSIZE( g_ppszRandomCombineModels );

+		

+		g_iLastCombineModel = ( g_iLastCombineModel + 1 ) % nHeads;

+		szModelName = g_ppszRandomCombineModels[g_iLastCombineModel];

+

+		m_iModelType = TEAM_COMBINE;

+	}

+	else if ( GetTeamNumber() == TEAM_REBELS )

+	{

+		int nHeads = ARRAYSIZE( g_ppszRandomCitizenModels );

+

+		g_iLastCitizenModel = ( g_iLastCitizenModel + 1 ) % nHeads;

+		szModelName = g_ppszRandomCitizenModels[g_iLastCitizenModel];

+

+		m_iModelType = TEAM_REBELS;

+	}

+	else

+	{

+		if ( Q_strlen( szModelName ) == 0 ) 

+		{

+			szModelName = g_ppszRandomCitizenModels[0];

+		}

+

+		if ( Q_stristr( szModelName, "models/human") )

+		{

+			m_iModelType = TEAM_REBELS;

+		}

+		else

+		{

+			m_iModelType = TEAM_COMBINE;

+		}

+	}

+

+	int modelIndex = modelinfo->GetModelIndex( szModelName );

+

+	if ( modelIndex == -1 )

+	{

+		szModelName = "models/Combine_Soldier.mdl";

+		m_iModelType = TEAM_COMBINE;

+

+		char szReturnString[512];

+

+		Q_snprintf( szReturnString, sizeof (szReturnString ), "cl_playermodel %s\n", szModelName );

+		engine->ClientCommand ( edict(), szReturnString );

+	}

+

+	SetModel( szModelName );

+	SetupPlayerSoundsByModel( szModelName );

+

+	m_flNextModelChangeTime = gpGlobals->curtime + MODEL_CHANGE_INTERVAL;

+}

+

+void CHL2MP_Player::SetupPlayerSoundsByModel( const char *pModelName )

+{

+	if ( Q_stristr( pModelName, "models/human") )

+	{

+		m_iPlayerSoundType = (int)PLAYER_SOUNDS_CITIZEN;

+	}

+	else if ( Q_stristr(pModelName, "police" ) )

+	{

+		m_iPlayerSoundType = (int)PLAYER_SOUNDS_METROPOLICE;

+	}

+	else if ( Q_stristr(pModelName, "combine" ) )

+	{

+		m_iPlayerSoundType = (int)PLAYER_SOUNDS_COMBINESOLDIER;

+	}

+}

+

+void CHL2MP_Player::ResetAnimation( void )

+{

+	if ( IsAlive() )

+	{

+		SetSequence ( -1 );

+		SetActivity( ACT_INVALID );

+

+		if (!GetAbsVelocity().x && !GetAbsVelocity().y)

+			SetAnimation( PLAYER_IDLE );

+		else if ((GetAbsVelocity().x || GetAbsVelocity().y) && ( GetFlags() & FL_ONGROUND ))

+			SetAnimation( PLAYER_WALK );

+		else if (GetWaterLevel() > 1)

+			SetAnimation( PLAYER_WALK );

+	}

+}

+

+

+bool CHL2MP_Player::Weapon_Switch( CBaseCombatWeapon *pWeapon, int viewmodelindex )

+{

+	bool bRet = BaseClass::Weapon_Switch( pWeapon, viewmodelindex );

+

+	if ( bRet == true )

+	{

+		ResetAnimation();

+	}

+

+	return bRet;

+}

+

+void CHL2MP_Player::PreThink( void )

+{

+	QAngle vOldAngles = GetLocalAngles();

+	QAngle vTempAngles = GetLocalAngles();

+

+	vTempAngles = EyeAngles();

+

+	if ( vTempAngles[PITCH] > 180.0f )

+	{

+		vTempAngles[PITCH] -= 360.0f;

+	}

+

+	SetLocalAngles( vTempAngles );

+

+	BaseClass::PreThink();

+	State_PreThink();

+

+	//Reset bullet force accumulator, only lasts one frame

+	m_vecTotalBulletForce = vec3_origin;

+	SetLocalAngles( vOldAngles );

+}

+

+void CHL2MP_Player::PostThink( void )

+{

+	BaseClass::PostThink();

+	

+	if ( GetFlags() & FL_DUCKING )

+	{

+		SetCollisionBounds( VEC_CROUCH_TRACE_MIN, VEC_CROUCH_TRACE_MAX );

+	}

+

+	m_PlayerAnimState.Update();

+

+	// Store the eye angles pitch so the client can compute its animation state correctly.

+	m_angEyeAngles = EyeAngles();

+

+	QAngle angles = GetLocalAngles();

+	angles[PITCH] = 0;

+	SetLocalAngles( angles );

+}

+

+void CHL2MP_Player::PlayerDeathThink()

+{

+	if( !IsObserver() )

+	{

+		BaseClass::PlayerDeathThink();

+	}

+}

+

+void CHL2MP_Player::FireBullets ( const FireBulletsInfo_t &info )

+{

+	// Move other players back to history positions based on local player's lag

+	lagcompensation->StartLagCompensation( this, this->GetCurrentCommand() );

+

+	FireBulletsInfo_t modinfo = info;

+

+	CWeaponHL2MPBase *pWeapon = dynamic_cast<CWeaponHL2MPBase *>( GetActiveWeapon() );

+

+	if ( pWeapon )

+	{

+		modinfo.m_iPlayerDamage = modinfo.m_flDamage = pWeapon->GetHL2MPWpnData().m_iPlayerDamage;

+	}

+

+	NoteWeaponFired();

+

+	BaseClass::FireBullets( modinfo );

+

+	// Move other players back to history positions based on local player's lag

+	lagcompensation->FinishLagCompensation( this );

+}

+

+void CHL2MP_Player::NoteWeaponFired( void )

+{

+	Assert( m_pCurrentCommand );

+	if( m_pCurrentCommand )

+	{

+		m_iLastWeaponFireUsercmd = m_pCurrentCommand->command_number;

+	}

+}

+

+extern ConVar sv_maxunlag;

+

+bool CHL2MP_Player::WantsLagCompensationOnEntity( const CBasePlayer *pPlayer, const CUserCmd *pCmd, const CBitVec<MAX_EDICTS> *pEntityTransmitBits ) const

+{

+	// No need to lag compensate at all if we're not attacking in this command and

+	// we haven't attacked recently.

+	if ( !( pCmd->buttons & IN_ATTACK ) && (pCmd->command_number - m_iLastWeaponFireUsercmd > 5) )

+		return false;

+

+	// If this entity hasn't been transmitted to us and acked, then don't bother lag compensating it.

+	if ( pEntityTransmitBits && !pEntityTransmitBits->Get( pPlayer->entindex() ) )

+		return false;

+

+	const Vector &vMyOrigin = GetAbsOrigin();

+	const Vector &vHisOrigin = pPlayer->GetAbsOrigin();

+

+	// get max distance player could have moved within max lag compensation time, 

+	// multiply by 1.5 to to avoid "dead zones"  (sqrt(2) would be the exact value)

+	float maxDistance = 1.5 * pPlayer->MaxSpeed() * sv_maxunlag.GetFloat();

+

+	// If the player is within this distance, lag compensate them in case they're running past us.

+	if ( vHisOrigin.DistTo( vMyOrigin ) < maxDistance )

+		return true;

+

+	// If their origin is not within a 45 degree cone in front of us, no need to lag compensate.

+	Vector vForward;

+	AngleVectors( pCmd->viewangles, &vForward );

+	

+	Vector vDiff = vHisOrigin - vMyOrigin;

+	VectorNormalize( vDiff );

+

+	float flCosAngle = 0.707107f;	// 45 degree angle

+	if ( vForward.Dot( vDiff ) < flCosAngle )

+		return false;

+

+	return true;

+}

+

+Activity CHL2MP_Player::TranslateTeamActivity( Activity ActToTranslate )

+{

+	if ( m_iModelType == TEAM_COMBINE )

+		 return ActToTranslate;

+	

+	if ( ActToTranslate == ACT_RUN )

+		 return ACT_RUN_AIM_AGITATED;

+

+	if ( ActToTranslate == ACT_IDLE )

+		 return ACT_IDLE_AIM_AGITATED;

+

+	if ( ActToTranslate == ACT_WALK )

+		 return ACT_WALK_AIM_AGITATED;

+

+	return ActToTranslate;

+}

+

+extern ConVar hl2_normspeed;

+

+// Set the activity based on an event or current state

+void CHL2MP_Player::SetAnimation( PLAYER_ANIM playerAnim )

+{

+	int animDesired;

+

+	float speed;

+

+	speed = GetAbsVelocity().Length2D();

+

+	

+	// bool bRunning = true;

+

+	//Revisit!

+/*	if ( ( m_nButtons & ( IN_FORWARD | IN_BACK | IN_MOVELEFT | IN_MOVERIGHT ) ) )

+	{

+		if ( speed > 1.0f && speed < hl2_normspeed.GetFloat() - 20.0f )

+		{

+			bRunning = false;

+		}

+	}*/

+

+	if ( GetFlags() & ( FL_FROZEN | FL_ATCONTROLS ) )

+	{

+		speed = 0;

+		playerAnim = PLAYER_IDLE;

+	}

+

+	Activity idealActivity = ACT_HL2MP_RUN;

+

+	// This could stand to be redone. Why is playerAnim abstracted from activity? (sjb)

+	if ( playerAnim == PLAYER_JUMP )

+	{

+		idealActivity = ACT_HL2MP_JUMP;

+	}

+	else if ( playerAnim == PLAYER_DIE )

+	{

+		if ( m_lifeState == LIFE_ALIVE )

+		{

+			return;

+		}

+	}

+	else if ( playerAnim == PLAYER_ATTACK1 )

+	{

+		if ( GetActivity( ) == ACT_HOVER	|| 

+			 GetActivity( ) == ACT_SWIM		||

+			 GetActivity( ) == ACT_HOP		||

+			 GetActivity( ) == ACT_LEAP		||

+			 GetActivity( ) == ACT_DIESIMPLE )

+		{

+			idealActivity = GetActivity( );

+		}

+		else

+		{

+			idealActivity = ACT_HL2MP_GESTURE_RANGE_ATTACK;

+		}

+	}

+	else if ( playerAnim == PLAYER_RELOAD )

+	{

+		idealActivity = ACT_HL2MP_GESTURE_RELOAD;

+	}

+	else if ( playerAnim == PLAYER_IDLE || playerAnim == PLAYER_WALK )

+	{

+		if ( !( GetFlags() & FL_ONGROUND ) && GetActivity( ) == ACT_HL2MP_JUMP )	// Still jumping

+		{

+			idealActivity = GetActivity( );

+		}

+		/*

+		else if ( GetWaterLevel() > 1 )

+		{

+			if ( speed == 0 )

+				idealActivity = ACT_HOVER;

+			else

+				idealActivity = ACT_SWIM;

+		}

+		*/

+		else

+		{

+			if ( GetFlags() & FL_DUCKING )

+			{

+				if ( speed > 0 )

+				{

+					idealActivity = ACT_HL2MP_WALK_CROUCH;

+				}

+				else

+				{

+					idealActivity = ACT_HL2MP_IDLE_CROUCH;

+				}

+			}

+			else

+			{

+				if ( speed > 0 )

+				{

+					/*

+					if ( bRunning == false )

+					{

+						idealActivity = ACT_WALK;

+					}

+					else

+					*/

+					{

+						idealActivity = ACT_HL2MP_RUN;

+					}

+				}

+				else

+				{

+					idealActivity = ACT_HL2MP_IDLE;

+				}

+			}

+		}

+

+		idealActivity = TranslateTeamActivity( idealActivity );

+	}

+	

+	if ( idealActivity == ACT_HL2MP_GESTURE_RANGE_ATTACK )

+	{

+		RestartGesture( Weapon_TranslateActivity( idealActivity ) );

+

+		// FIXME: this seems a bit wacked

+		Weapon_SetActivity( Weapon_TranslateActivity( ACT_RANGE_ATTACK1 ), 0 );

+

+		return;

+	}

+	else if ( idealActivity == ACT_HL2MP_GESTURE_RELOAD )

+	{

+		RestartGesture( Weapon_TranslateActivity( idealActivity ) );

+		return;

+	}

+	else

+	{

+		SetActivity( idealActivity );

+

+		animDesired = SelectWeightedSequence( Weapon_TranslateActivity ( idealActivity ) );

+

+		if (animDesired == -1)

+		{

+			animDesired = SelectWeightedSequence( idealActivity );

+

+			if ( animDesired == -1 )

+			{

+				animDesired = 0;

+			}

+		}

+	

+		// Already using the desired animation?

+		if ( GetSequence() == animDesired )

+			return;

+

+		m_flPlaybackRate = 1.0;

+		ResetSequence( animDesired );

+		SetCycle( 0 );

+		return;

+	}

+

+	// Already using the desired animation?

+	if ( GetSequence() == animDesired )

+		return;

+

+	//Msg( "Set animation to %d\n", animDesired );

+	// Reset to first frame of desired animation

+	ResetSequence( animDesired );

+	SetCycle( 0 );

+}

+

+

+extern int	gEvilImpulse101;

+//-----------------------------------------------------------------------------

+// Purpose: Player reacts to bumping a weapon. 

+// Input  : pWeapon - the weapon that the player bumped into.

+// Output : Returns true if player picked up the weapon

+//-----------------------------------------------------------------------------

+bool CHL2MP_Player::BumpWeapon( CBaseCombatWeapon *pWeapon )

+{

+	CBaseCombatCharacter *pOwner = pWeapon->GetOwner();

+

+	// Can I have this weapon type?

+	if ( !IsAllowedToPickupWeapons() )

+		return false;

+

+	if ( pOwner || !Weapon_CanUse( pWeapon ) || !g_pGameRules->CanHavePlayerItem( this, pWeapon ) )

+	{

+		if ( gEvilImpulse101 )

+		{

+			UTIL_Remove( pWeapon );

+		}

+		return false;

+	}

+

+	// Don't let the player fetch weapons through walls (use MASK_SOLID so that you can't pickup through windows)

+	if( !pWeapon->FVisible( this, MASK_SOLID ) && !(GetFlags() & FL_NOTARGET) )

+	{

+		return false;

+	}

+

+	bool bOwnsWeaponAlready = !!Weapon_OwnsThisType( pWeapon->GetClassname(), pWeapon->GetSubType());

+

+	if ( bOwnsWeaponAlready == true ) 

+	{

+		//If we have room for the ammo, then "take" the weapon too.

+		 if ( Weapon_EquipAmmoOnly( pWeapon ) )

+		 {

+			 pWeapon->CheckRespawn();

+

+			 UTIL_Remove( pWeapon );

+			 return true;

+		 }

+		 else

+		 {

+			 return false;

+		 }

+	}

+

+	pWeapon->CheckRespawn();

+	Weapon_Equip( pWeapon );

+

+	return true;

+}

+

+void CHL2MP_Player::ChangeTeam( int iTeam )

+{

+/*	if ( GetNextTeamChangeTime() >= gpGlobals->curtime )

+	{

+		char szReturnString[128];

+		Q_snprintf( szReturnString, sizeof( szReturnString ), "Please wait %d more seconds before trying to switch teams again.\n", (int)(GetNextTeamChangeTime() - gpGlobals->curtime) );

+

+		ClientPrint( this, HUD_PRINTTALK, szReturnString );

+		return;

+	}*/

+

+	bool bKill = false;

+

+	if ( HL2MPRules()->IsTeamplay() != true && iTeam != TEAM_SPECTATOR )

+	{

+		//don't let them try to join combine or rebels during deathmatch.

+		iTeam = TEAM_UNASSIGNED;

+	}

+

+	if ( HL2MPRules()->IsTeamplay() == true )

+	{

+		if ( iTeam != GetTeamNumber() && GetTeamNumber() != TEAM_UNASSIGNED )

+		{

+			bKill = true;

+		}

+	}

+

+	BaseClass::ChangeTeam( iTeam );

+

+	m_flNextTeamChangeTime = gpGlobals->curtime + TEAM_CHANGE_INTERVAL;

+

+	if ( HL2MPRules()->IsTeamplay() == true )

+	{

+		SetPlayerTeamModel();

+	}

+	else

+	{

+		SetPlayerModel();

+	}

+

+	if ( iTeam == TEAM_SPECTATOR )

+	{

+		RemoveAllItems( true );

+

+		State_Transition( STATE_OBSERVER_MODE );

+	}

+

+	if ( bKill == true )

+	{

+		CommitSuicide();

+	}

+}

+

+bool CHL2MP_Player::HandleCommand_JoinTeam( int team )

+{

+	if ( !GetGlobalTeam( team ) || team == 0 )

+	{

+		Warning( "HandleCommand_JoinTeam( %d ) - invalid team index.\n", team );

+		return false;

+	}

+

+	if ( team == TEAM_SPECTATOR )

+	{

+		// Prevent this is the cvar is set

+		if ( !mp_allowspectators.GetInt() )

+		{

+			ClientPrint( this, HUD_PRINTCENTER, "#Cannot_Be_Spectator" );

+			return false;

+		}

+

+		if ( GetTeamNumber() != TEAM_UNASSIGNED && !IsDead() )

+		{

+			m_fNextSuicideTime = gpGlobals->curtime;	// allow the suicide to work

+

+			CommitSuicide();

+

+			// add 1 to frags to balance out the 1 subtracted for killing yourself

+			IncrementFragCount( 1 );

+		}

+

+		ChangeTeam( TEAM_SPECTATOR );

+

+		return true;

+	}

+	else

+	{

+		StopObserverMode();

+		State_Transition(STATE_ACTIVE);

+	}

+

+	// Switch their actual team...

+	ChangeTeam( team );

+

+	return true;

+}

+

+bool CHL2MP_Player::ClientCommand( const CCommand &args )

+{

+	if ( FStrEq( args[0], "spectate" ) )

+	{

+		if ( ShouldRunRateLimitedCommand( args ) )

+		{

+			// instantly join spectators

+			HandleCommand_JoinTeam( TEAM_SPECTATOR );	

+		}

+		return true;

+	}

+	else if ( FStrEq( args[0], "jointeam" ) ) 

+	{

+		if ( args.ArgC() < 2 )

+		{

+			Warning( "Player sent bad jointeam syntax\n" );

+		}

+

+		if ( ShouldRunRateLimitedCommand( args ) )

+		{

+			int iTeam = atoi( args[1] );

+			HandleCommand_JoinTeam( iTeam );

+		}

+		return true;

+	}

+	else if ( FStrEq( args[0], "joingame" ) )

+	{

+		return true;

+	}

+

+	return BaseClass::ClientCommand( args );

+}

+

+void CHL2MP_Player::CheatImpulseCommands( int iImpulse )

+{

+	switch ( iImpulse )

+	{

+		case 101:

+			{

+				if( sv_cheats->GetBool() )

+				{

+					GiveAllItems();

+				}

+			}

+			break;

+

+		default:

+			BaseClass::CheatImpulseCommands( iImpulse );

+	}

+}

+

+bool CHL2MP_Player::ShouldRunRateLimitedCommand( const CCommand &args )

+{

+	int i = m_RateLimitLastCommandTimes.Find( args[0] );

+	if ( i == m_RateLimitLastCommandTimes.InvalidIndex() )

+	{

+		m_RateLimitLastCommandTimes.Insert( args[0], gpGlobals->curtime );

+		return true;

+	}

+	else if ( (gpGlobals->curtime - m_RateLimitLastCommandTimes[i]) < HL2MP_COMMAND_MAX_RATE )

+	{

+		// Too fast.

+		return false;

+	}

+	else

+	{

+		m_RateLimitLastCommandTimes[i] = gpGlobals->curtime;

+		return true;

+	}

+}

+

+void CHL2MP_Player::CreateViewModel( int index /*=0*/ )

+{

+	Assert( index >= 0 && index < MAX_VIEWMODELS );

+

+	if ( GetViewModel( index ) )

+		return;

+

+	CPredictedViewModel *vm = ( CPredictedViewModel * )CreateEntityByName( "predicted_viewmodel" );

+	if ( vm )

+	{

+		vm->SetAbsOrigin( GetAbsOrigin() );

+		vm->SetOwner( this );

+		vm->SetIndex( index );

+		DispatchSpawn( vm );

+		vm->FollowEntity( this, false );

+		m_hViewModel.Set( index, vm );

+	}

+}

+

+bool CHL2MP_Player::BecomeRagdollOnClient( const Vector &force )

+{

+	return true;

+}

+

+// -------------------------------------------------------------------------------- //

+// Ragdoll entities.

+// -------------------------------------------------------------------------------- //

+

+class CHL2MPRagdoll : public CBaseAnimatingOverlay

+{

+public:

+	DECLARE_CLASS( CHL2MPRagdoll, CBaseAnimatingOverlay );

+	DECLARE_SERVERCLASS();

+

+	// Transmit ragdolls to everyone.

+	virtual int UpdateTransmitState()

+	{

+		return SetTransmitState( FL_EDICT_ALWAYS );

+	}

+

+public:

+	// In case the client has the player entity, we transmit the player index.

+	// In case the client doesn't have it, we transmit the player's model index, origin, and angles

+	// so they can create a ragdoll in the right place.

+	CNetworkHandle( CBaseEntity, m_hPlayer );	// networked entity handle 

+	CNetworkVector( m_vecRagdollVelocity );

+	CNetworkVector( m_vecRagdollOrigin );

+};

+

+LINK_ENTITY_TO_CLASS( hl2mp_ragdoll, CHL2MPRagdoll );

+

+IMPLEMENT_SERVERCLASS_ST_NOBASE( CHL2MPRagdoll, DT_HL2MPRagdoll )

+	SendPropVector( SENDINFO(m_vecRagdollOrigin), -1,  SPROP_COORD ),

+	SendPropEHandle( SENDINFO( m_hPlayer ) ),

+	SendPropModelIndex( SENDINFO( m_nModelIndex ) ),

+	SendPropInt		( SENDINFO(m_nForceBone), 8, 0 ),

+	SendPropVector	( SENDINFO(m_vecForce), -1, SPROP_NOSCALE ),

+	SendPropVector( SENDINFO( m_vecRagdollVelocity ) )

+END_SEND_TABLE()

+

+

+void CHL2MP_Player::CreateRagdollEntity( void )

+{

+	if ( m_hRagdoll )

+	{

+		UTIL_RemoveImmediate( m_hRagdoll );

+		m_hRagdoll = NULL;

+	}

+

+	// If we already have a ragdoll, don't make another one.

+	CHL2MPRagdoll *pRagdoll = dynamic_cast< CHL2MPRagdoll* >( m_hRagdoll.Get() );

+	

+	if ( !pRagdoll )

+	{

+		// create a new one

+		pRagdoll = dynamic_cast< CHL2MPRagdoll* >( CreateEntityByName( "hl2mp_ragdoll" ) );

+	}

+

+	if ( pRagdoll )

+	{

+		pRagdoll->m_hPlayer = this;

+		pRagdoll->m_vecRagdollOrigin = GetAbsOrigin();

+		pRagdoll->m_vecRagdollVelocity = GetAbsVelocity();

+		pRagdoll->m_nModelIndex = m_nModelIndex;

+		pRagdoll->m_nForceBone = m_nForceBone;

+		pRagdoll->m_vecForce = m_vecTotalBulletForce;

+		pRagdoll->SetAbsOrigin( GetAbsOrigin() );

+	}

+

+	// ragdolls will be removed on round restart automatically

+	m_hRagdoll = pRagdoll;

+}

+

+//-----------------------------------------------------------------------------

+//-----------------------------------------------------------------------------

+int CHL2MP_Player::FlashlightIsOn( void )

+{

+	return IsEffectActive( EF_DIMLIGHT );

+}

+

+extern ConVar flashlight;

+

+//-----------------------------------------------------------------------------

+//-----------------------------------------------------------------------------

+void CHL2MP_Player::FlashlightTurnOn( void )

+{

+	if( flashlight.GetInt() > 0 && IsAlive() )

+	{

+		AddEffects( EF_DIMLIGHT );

+		EmitSound( "HL2Player.FlashlightOn" );

+	}

+}

+

+

+//-----------------------------------------------------------------------------

+//-----------------------------------------------------------------------------

+void CHL2MP_Player::FlashlightTurnOff( void )

+{

+	RemoveEffects( EF_DIMLIGHT );

+	

+	if( IsAlive() )

+	{

+		EmitSound( "HL2Player.FlashlightOff" );

+	}

+}

+

+void CHL2MP_Player::Weapon_Drop( CBaseCombatWeapon *pWeapon, const Vector *pvecTarget, const Vector *pVelocity )

+{

+	//Drop a grenade if it's primed.

+	if ( GetActiveWeapon() )

+	{

+		CBaseCombatWeapon *pGrenade = Weapon_OwnsThisType("weapon_frag");

+

+		if ( GetActiveWeapon() == pGrenade )

+		{

+			if ( ( m_nButtons & IN_ATTACK ) || (m_nButtons & IN_ATTACK2) )

+			{

+				DropPrimedFragGrenade( this, pGrenade );

+				return;

+			}

+		}

+	}

+

+	BaseClass::Weapon_Drop( pWeapon, pvecTarget, pVelocity );

+}

+

+

+void CHL2MP_Player::DetonateTripmines( void )

+{

+	CBaseEntity *pEntity = NULL;

+

+	while ((pEntity = gEntList.FindEntityByClassname( pEntity, "npc_satchel" )) != NULL)

+	{

+		CSatchelCharge *pSatchel = dynamic_cast<CSatchelCharge *>(pEntity);

+		if (pSatchel->m_bIsLive && pSatchel->GetThrower() == this )

+		{

+			g_EventQueue.AddEvent( pSatchel, "Explode", 0.20, this, this );

+		}

+	}

+

+	// Play sound for pressing the detonator

+	EmitSound( "Weapon_SLAM.SatchelDetonate" );

+}

+

+void CHL2MP_Player::Event_Killed( const CTakeDamageInfo &info )

+{

+	//update damage info with our accumulated physics force

+	CTakeDamageInfo subinfo = info;

+	subinfo.SetDamageForce( m_vecTotalBulletForce );

+

+	SetNumAnimOverlays( 0 );

+

+	// Note: since we're dead, it won't draw us on the client, but we don't set EF_NODRAW

+	// because we still want to transmit to the clients in our PVS.

+	CreateRagdollEntity();

+

+	DetonateTripmines();

+

+	BaseClass::Event_Killed( subinfo );

+

+	if ( info.GetDamageType() & DMG_DISSOLVE )

+	{

+		if ( m_hRagdoll )

+		{

+			m_hRagdoll->GetBaseAnimating()->Dissolve( NULL, gpGlobals->curtime, false, ENTITY_DISSOLVE_NORMAL );

+		}

+	}

+

+	CBaseEntity *pAttacker = info.GetAttacker();

+

+	if ( pAttacker )

+	{

+		int iScoreToAdd = 1;

+

+		if ( pAttacker == this )

+		{

+			iScoreToAdd = -1;

+		}

+

+		GetGlobalTeam( pAttacker->GetTeamNumber() )->AddScore( iScoreToAdd );

+	}

+

+	FlashlightTurnOff();

+

+	m_lifeState = LIFE_DEAD;

+

+	RemoveEffects( EF_NODRAW );	// still draw player body

+	StopZooming();

+}

+

+int CHL2MP_Player::OnTakeDamage( const CTakeDamageInfo &inputInfo )

+{

+	//return here if the player is in the respawn grace period vs. slams.

+	if ( gpGlobals->curtime < m_flSlamProtectTime &&  (inputInfo.GetDamageType() == DMG_BLAST ) )

+		return 0;

+

+	m_vecTotalBulletForce += inputInfo.GetDamageForce();

+	

+	gamestats->Event_PlayerDamage( this, inputInfo );

+

+	return BaseClass::OnTakeDamage( inputInfo );

+}

+

+void CHL2MP_Player::DeathSound( const CTakeDamageInfo &info )

+{

+	if ( m_hRagdoll && m_hRagdoll->GetBaseAnimating()->IsDissolving() )

+		 return;

+

+	char szStepSound[128];

+

+	Q_snprintf( szStepSound, sizeof( szStepSound ), "%s.Die", GetPlayerModelSoundPrefix() );

+

+	const char *pModelName = STRING( GetModelName() );

+

+	CSoundParameters params;

+	if ( GetParametersForSound( szStepSound, params, pModelName ) == false )

+		return;

+

+	Vector vecOrigin = GetAbsOrigin();

+	

+	CRecipientFilter filter;

+	filter.AddRecipientsByPAS( vecOrigin );

+

+	EmitSound_t ep;

+	ep.m_nChannel = params.channel;

+	ep.m_pSoundName = params.soundname;

+	ep.m_flVolume = params.volume;

+	ep.m_SoundLevel = params.soundlevel;

+	ep.m_nFlags = 0;

+	ep.m_nPitch = params.pitch;

+	ep.m_pOrigin = &vecOrigin;

+

+	EmitSound( filter, entindex(), ep );

+}

+

+CBaseEntity* CHL2MP_Player::EntSelectSpawnPoint( void )

+{

+	CBaseEntity *pSpot = NULL;

+	CBaseEntity *pLastSpawnPoint = g_pLastSpawn;

+	edict_t		*player = edict();

+	const char *pSpawnpointName = "info_player_deathmatch";

+

+	if ( HL2MPRules()->IsTeamplay() == true )

+	{

+		if ( GetTeamNumber() == TEAM_COMBINE )

+		{

+			pSpawnpointName = "info_player_combine";

+			pLastSpawnPoint = g_pLastCombineSpawn;

+		}

+		else if ( GetTeamNumber() == TEAM_REBELS )

+		{

+			pSpawnpointName = "info_player_rebel";

+			pLastSpawnPoint = g_pLastRebelSpawn;

+		}

+

+		if ( gEntList.FindEntityByClassname( NULL, pSpawnpointName ) == NULL )

+		{

+			pSpawnpointName = "info_player_deathmatch";

+			pLastSpawnPoint = g_pLastSpawn;

+		}

+	}

+

+	pSpot = pLastSpawnPoint;

+	// Randomize the start spot

+	for ( int i = random->RandomInt(1,5); i > 0; i-- )

+		pSpot = gEntList.FindEntityByClassname( pSpot, pSpawnpointName );

+	if ( !pSpot )  // skip over the null point

+		pSpot = gEntList.FindEntityByClassname( pSpot, pSpawnpointName );

+

+	CBaseEntity *pFirstSpot = pSpot;

+

+	do 

+	{

+		if ( pSpot )

+		{

+			// check if pSpot is valid

+			if ( g_pGameRules->IsSpawnPointValid( pSpot, this ) )

+			{

+				if ( pSpot->GetLocalOrigin() == vec3_origin )

+				{

+					pSpot = gEntList.FindEntityByClassname( pSpot, pSpawnpointName );

+					continue;

+				}

+

+				// if so, go to pSpot

+				goto ReturnSpot;

+			}

+		}

+		// increment pSpot

+		pSpot = gEntList.FindEntityByClassname( pSpot, pSpawnpointName );

+	} while ( pSpot != pFirstSpot ); // loop if we're not back to the start

+

+	// we haven't found a place to spawn yet,  so kill any guy at the first spawn point and spawn there

+	if ( pSpot )

+	{

+		CBaseEntity *ent = NULL;

+		for ( CEntitySphereQuery sphere( pSpot->GetAbsOrigin(), 128 ); (ent = sphere.GetCurrentEntity()) != NULL; sphere.NextEntity() )

+		{

+			// if ent is a client, kill em (unless they are ourselves)

+			if ( ent->IsPlayer() && !(ent->edict() == player) )

+				ent->TakeDamage( CTakeDamageInfo( GetContainingEntity(INDEXENT(0)), GetContainingEntity(INDEXENT(0)), 300, DMG_GENERIC ) );

+		}

+		goto ReturnSpot;

+	}

+

+	if ( !pSpot  )

+	{

+		pSpot = gEntList.FindEntityByClassname( pSpot, "info_player_start" );

+

+		if ( pSpot )

+			goto ReturnSpot;

+	}

+

+ReturnSpot:

+

+	if ( HL2MPRules()->IsTeamplay() == true )

+	{

+		if ( GetTeamNumber() == TEAM_COMBINE )

+		{

+			g_pLastCombineSpawn = pSpot;

+		}

+		else if ( GetTeamNumber() == TEAM_REBELS ) 

+		{

+			g_pLastRebelSpawn = pSpot;

+		}

+	}

+

+	g_pLastSpawn = pSpot;

+

+	m_flSlamProtectTime = gpGlobals->curtime + 0.5;

+

+	return pSpot;

+} 

+

+

+CON_COMMAND( timeleft, "prints the time remaining in the match" )

+{

+	CHL2MP_Player *pPlayer = ToHL2MPPlayer( UTIL_GetCommandClient() );

+

+	int iTimeRemaining = (int)HL2MPRules()->GetMapRemainingTime();

+    

+	if ( iTimeRemaining == 0 )

+	{

+		if ( pPlayer )

+		{

+			ClientPrint( pPlayer, HUD_PRINTTALK, "This game has no timelimit." );

+		}

+		else

+		{

+			Msg( "* No Time Limit *\n" );

+		}

+	}

+	else

+	{

+		int iMinutes, iSeconds;

+		iMinutes = iTimeRemaining / 60;

+		iSeconds = iTimeRemaining % 60;

+

+		char minutes[8];

+		char seconds[8];

+

+		Q_snprintf( minutes, sizeof(minutes), "%d", iMinutes );

+		Q_snprintf( seconds, sizeof(seconds), "%2.2d", iSeconds );

+

+		if ( pPlayer )

+		{

+			ClientPrint( pPlayer, HUD_PRINTTALK, "Time left in map: %s1:%s2", minutes, seconds );

+		}

+		else

+		{

+			Msg( "Time Remaining:  %s:%s\n", minutes, seconds );

+		}

+	}	

+}

+

+

+void CHL2MP_Player::Reset()

+{	

+	ResetDeathCount();

+	ResetFragCount();

+}

+

+bool CHL2MP_Player::IsReady()

+{

+	return m_bReady;

+}

+

+void CHL2MP_Player::SetReady( bool bReady )

+{

+	m_bReady = bReady;

+}

+

+void CHL2MP_Player::CheckChatText( char *p, int bufsize )

+{

+	//Look for escape sequences and replace

+

+	char *buf = new char[bufsize];

+	int pos = 0;

+

+	// Parse say text for escape sequences

+	for ( char *pSrc = p; pSrc != NULL && *pSrc != 0 && pos < bufsize-1; pSrc++ )

+	{

+		// copy each char across

+		buf[pos] = *pSrc;

+		pos++;

+	}

+

+	buf[pos] = '\0';

+

+	// copy buf back into p

+	Q_strncpy( p, buf, bufsize );

+

+	delete[] buf;	

+

+	const char *pReadyCheck = p;

+

+	HL2MPRules()->CheckChatForReadySignal( this, pReadyCheck );

+}

+

+void CHL2MP_Player::State_Transition( HL2MPPlayerState newState )

+{

+	State_Leave();

+	State_Enter( newState );

+}

+

+

+void CHL2MP_Player::State_Enter( HL2MPPlayerState newState )

+{

+	m_iPlayerState = newState;

+	m_pCurStateInfo = State_LookupInfo( newState );

+

+	// Initialize the new state.

+	if ( m_pCurStateInfo && m_pCurStateInfo->pfnEnterState )

+		(this->*m_pCurStateInfo->pfnEnterState)();

+}

+

+

+void CHL2MP_Player::State_Leave()

+{

+	if ( m_pCurStateInfo && m_pCurStateInfo->pfnLeaveState )

+	{

+		(this->*m_pCurStateInfo->pfnLeaveState)();

+	}

+}

+

+

+void CHL2MP_Player::State_PreThink()

+{

+	if ( m_pCurStateInfo && m_pCurStateInfo->pfnPreThink )

+	{

+		(this->*m_pCurStateInfo->pfnPreThink)();

+	}

+}

+

+

+CHL2MPPlayerStateInfo *CHL2MP_Player::State_LookupInfo( HL2MPPlayerState state )

+{

+	// This table MUST match the 

+	static CHL2MPPlayerStateInfo playerStateInfos[] =

+	{

+		{ STATE_ACTIVE,			"STATE_ACTIVE",			&CHL2MP_Player::State_Enter_ACTIVE, NULL, &CHL2MP_Player::State_PreThink_ACTIVE },

+		{ STATE_OBSERVER_MODE,	"STATE_OBSERVER_MODE",	&CHL2MP_Player::State_Enter_OBSERVER_MODE,	NULL, &CHL2MP_Player::State_PreThink_OBSERVER_MODE }

+	};

+

+	for ( int i=0; i < ARRAYSIZE( playerStateInfos ); i++ )

+	{

+		if ( playerStateInfos[i].m_iPlayerState == state )

+			return &playerStateInfos[i];

+	}

+

+	return NULL;

+}

+

+bool CHL2MP_Player::StartObserverMode(int mode)

+{

+	//we only want to go into observer mode if the player asked to, not on a death timeout

+	if ( m_bEnterObserver == true )

+	{

+		VPhysicsDestroyObject();

+		return BaseClass::StartObserverMode( mode );

+	}

+	return false;

+}

+

+void CHL2MP_Player::StopObserverMode()

+{

+	m_bEnterObserver = false;

+	BaseClass::StopObserverMode();

+}

+

+void CHL2MP_Player::State_Enter_OBSERVER_MODE()

+{

+	int observerMode = m_iObserverLastMode;

+	if ( IsNetClient() )

+	{

+		const char *pIdealMode = engine->GetClientConVarValue( engine->IndexOfEdict( edict() ), "cl_spec_mode" );

+		if ( pIdealMode )

+		{

+			observerMode = atoi( pIdealMode );

+			if ( observerMode <= OBS_MODE_FIXED || observerMode > OBS_MODE_ROAMING )

+			{

+				observerMode = m_iObserverLastMode;

+			}

+		}

+	}

+	m_bEnterObserver = true;

+	StartObserverMode( observerMode );

+}

+

+void CHL2MP_Player::State_PreThink_OBSERVER_MODE()

+{

+	// Make sure nobody has changed any of our state.

+	//	Assert( GetMoveType() == MOVETYPE_FLY );

+	Assert( m_takedamage == DAMAGE_NO );

+	Assert( IsSolidFlagSet( FSOLID_NOT_SOLID ) );

+	//	Assert( IsEffectActive( EF_NODRAW ) );

+

+	// Must be dead.

+	Assert( m_lifeState == LIFE_DEAD );

+	Assert( pl.deadflag );

+}

+

+

+void CHL2MP_Player::State_Enter_ACTIVE()

+{

+	SetMoveType( MOVETYPE_WALK );

+	

+	// md 8/15/07 - They'll get set back to solid when they actually respawn. If we set them solid now and mp_forcerespawn

+	// is false, then they'll be spectating but blocking live players from moving.

+	// RemoveSolidFlags( FSOLID_NOT_SOLID );

+	

+	m_Local.m_iHideHUD = 0;

+}

+

+

+void CHL2MP_Player::State_PreThink_ACTIVE()

+{

+	//we don't really need to do anything here. 

+	//This state_prethink structure came over from CS:S and was doing an assert check that fails the way hl2dm handles death

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+bool CHL2MP_Player::CanHearAndReadChatFrom( CBasePlayer *pPlayer )

+{

+	// can always hear the console unless we're ignoring all chat

+	if ( !pPlayer )

+		return false;

+

+	return true;

+}