1HEADmaster

1 files changed, 1283 insertions, 0 deletions

diff --git a/game/shared/portal/portal_mp_gamerules.cpp b/game/shared/portal/portal_mp_gamerules.cpp
new file mode 100644
index 0000000..4e2ad28
--- /dev/null
+++ b/game/shared/portal/portal_mp_gamerules.cpp
@@ -0,0 +1,1283 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: The Half-Life 2 game rules, such as the relationship tables and ammo
+//			damage cvars.
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "portal_gamerules.h"
+#include "viewport_panel_names.h"
+#include "gameeventdefs.h"
+#include <KeyValues.h>
+#include "ammodef.h"
+#include "hl2_shareddefs.h"
+
+#ifdef CLIENT_DLL
+#include "c_portal_player.h"
+#else
+
+#include "eventqueue.h"
+#include "player.h"
+#include "gamerules.h"
+#include "game.h"
+#include "items.h"
+#include "entitylist.h"
+#include "mapentities.h"
+#include "in_buttons.h"
+#include <ctype.h>
+#include "voice_gamemgr.h"
+#include "iscorer.h"
+#include "portal_player.h"
+//#include "weapon_hl2mpbasehlmpcombatweapon.h"
+#include "team.h"
+#include "voice_gamemgr.h"
+
+
+extern void respawn(CBaseEntity *pEdict, bool fCopyCorpse);
+
+
+ConVar sv_hl2mp_weapon_respawn_time( "sv_hl2mp_weapon_respawn_time", "20", FCVAR_GAMEDLL | FCVAR_NOTIFY );
+ConVar sv_hl2mp_item_respawn_time( "sv_hl2mp_item_respawn_time", "30", FCVAR_GAMEDLL | FCVAR_NOTIFY );
+ConVar mp_restartgame( "mp_restartgame", "0", 0, "If non-zero, game will restart in the specified number of seconds" );
+ConVar sv_report_client_settings("sv_report_client_settings", "0", FCVAR_GAMEDLL | FCVAR_NOTIFY );
+
+extern ConVar mp_chattime;
+
+#define WEAPON_MAX_DISTANCE_FROM_SPAWN 64
+
+#endif
+
+
+REGISTER_GAMERULES_CLASS( CPortalMPGameRules );
+
+BEGIN_NETWORK_TABLE_NOBASE( CPortalMPGameRules, DT_PortalMPGameRules )
+
+#ifdef CLIENT_DLL
+RecvPropBool( RECVINFO( m_bTeamPlayEnabled ) ),
+#else
+SendPropBool( SENDINFO( m_bTeamPlayEnabled ) ),
+#endif
+
+END_NETWORK_TABLE()
+
+
+LINK_ENTITY_TO_CLASS( portalmp_gamerules, CPortalMPGameRulesProxy );
+IMPLEMENT_NETWORKCLASS_ALIASED( PortalMPGameRulesProxy, DT_PortalMPGameRulesProxy )
+
+static PortalMPViewVectors g_PortalMPViewVectors(
+	Vector( 0, 0, 64 ),       //VEC_VIEW (m_vView) 
+
+	Vector(-16, -16, 0 ),	  //VEC_HULL_MIN (m_vHullMin)
+	Vector( 16,  16,  72 ),	  //VEC_HULL_MAX (m_vHullMax)
+
+	Vector(-16, -16, 0 ),	  //VEC_DUCK_HULL_MIN (m_vDuckHullMin)
+	Vector( 16,  16,  36 ),	  //VEC_DUCK_HULL_MAX	(m_vDuckHullMax)
+	Vector( 0, 0, 28 ),		  //VEC_DUCK_VIEW		(m_vDuckView)
+
+	Vector(-10, -10, -10 ),	  //VEC_OBS_HULL_MIN	(m_vObsHullMin)
+	Vector( 10,  10,  10 ),	  //VEC_OBS_HULL_MAX	(m_vObsHullMax)
+
+	Vector( 0, 0, 14 ),		  //VEC_DEAD_VIEWHEIGHT (m_vDeadViewHeight)
+
+	Vector(-16, -16, 0 ),	  //VEC_CROUCH_TRACE_MIN (m_vCrouchTraceMin)
+	Vector( 16,  16,  60 )	  //VEC_CROUCH_TRACE_MAX (m_vCrouchTraceMax)
+	);
+
+static const char *s_PreserveEnts[] =
+{
+	"ai_network",
+		"ai_hint",
+		"hl2mp_gamerules",
+		"team_manager",
+		"player_manager",
+		"env_soundscape",
+		"env_soundscape_proxy",
+		"env_soundscape_triggerable",
+		"env_sun",
+		"env_wind",
+		"env_fog_controller",
+		"func_brush",
+		"func_wall",
+		"func_buyzone",
+		"func_illusionary",
+		"infodecal",
+		"info_projecteddecal",
+		"info_node",
+		"info_target",
+		"info_node_hint",
+		"info_player_deathmatch",
+		"info_player_combine",
+		"info_player_rebel",
+		"info_map_parameters",
+		"keyframe_rope",
+		"move_rope",
+		"info_ladder",
+		"player",
+		"point_viewcontrol",
+		"scene_manager",
+		"shadow_control",
+		"sky_camera",
+		"soundent",
+		"trigger_soundscape",
+		"viewmodel",
+		"predicted_viewmodel",
+		"worldspawn",
+		"point_devshot_camera",
+		"", // END Marker
+};
+
+
+
+#ifdef CLIENT_DLL
+void RecvProxy_PortalMPRules( const RecvProp *pProp, void **pOut, void *pData, int objectID )
+{
+	CPortalMPGameRules *pRules = PortalMPGameRules();
+	Assert( pRules );
+	*pOut = pRules;
+}
+
+BEGIN_RECV_TABLE( CPortalMPGameRulesProxy, DT_PortalMPGameRulesProxy )
+RecvPropDataTable( "portalmp_gamerules_data", 0, 0, &REFERENCE_RECV_TABLE( DT_PortalMPGameRules ), RecvProxy_PortalMPRules )
+END_RECV_TABLE()
+#else
+void* SendProxy_PortalMPRules( const SendProp *pProp, const void *pStructBase, const void *pData, CSendProxyRecipients *pRecipients, int objectID )
+{
+	CPortalMPGameRules *pRules = PortalMPGameRules();
+	Assert( pRules );
+	return pRules;
+}
+
+BEGIN_SEND_TABLE( CPortalMPGameRulesProxy, DT_PortalMPGameRulesProxy )
+SendPropDataTable( "portalmp_gamerules_data", 0, &REFERENCE_SEND_TABLE( DT_PortalMPGameRules ), SendProxy_PortalMPRules )
+END_SEND_TABLE()
+#endif
+
+#ifndef CLIENT_DLL
+
+class CVoiceGameMgrHelper : public IVoiceGameMgrHelper
+{
+public:
+	virtual bool		CanPlayerHearPlayer( CBasePlayer *pListener, CBasePlayer *pTalker )
+	{
+		return ( pListener->GetTeamNumber() == pTalker->GetTeamNumber() );
+	}
+};
+CVoiceGameMgrHelper g_VoiceGameMgrHelper;
+IVoiceGameMgrHelper *g_pVoiceGameMgrHelper = &g_VoiceGameMgrHelper;
+
+#endif
+
+// NOTE: the indices here must match TEAM_TERRORIST, TEAM_CT, TEAM_SPECTATOR, etc.
+char *sTeamNames[] =
+{
+	"Unassigned",
+		"Spectator",
+		"Combine",
+		"Rebels",
+};
+
+CPortalMPGameRules::CPortalMPGameRules()
+{
+#ifndef CLIENT_DLL
+	// Create the team managers
+	for ( int i = 0; i < ARRAYSIZE( sTeamNames ); i++ )
+	{
+		CTeam *pTeam = static_cast<CTeam*>(CreateEntityByName( "team_manager" ));
+		pTeam->Init( sTeamNames[i], i );
+
+		g_Teams.AddToTail( pTeam );
+	}
+
+	m_bTeamPlayEnabled = teamplay.GetBool();
+	m_flIntermissionEndTime = 0.0f;
+	m_flGameStartTime = 0;
+
+	m_hRespawnableItemsAndWeapons.RemoveAll();
+	m_tmNextPeriodicThink = 0;
+	m_flRestartGameTime = 0;
+	m_bCompleteReset = false;
+	m_bHeardAllPlayersReady = false;
+	m_bAwaitingReadyRestart = false;
+
+#endif
+}
+
+const CViewVectors* CPortalMPGameRules::GetViewVectors()const
+{
+	return &g_PortalMPViewVectors;
+}
+
+const PortalMPViewVectors* CPortalMPGameRules::GetPortalMPViewVectors()const
+{
+	return &g_PortalMPViewVectors;
+}
+
+CPortalMPGameRules::~CPortalMPGameRules( void )
+{
+#ifndef CLIENT_DLL
+	// Note, don't delete each team since they are in the gEntList and will 
+	// automatically be deleted from there, instead.
+	g_Teams.Purge();
+#endif
+}
+
+void CPortalMPGameRules::CreateStandardEntities( void )
+{
+
+#ifndef CLIENT_DLL
+	// Create the entity that will send our data to the client.
+
+	BaseClass::CreateStandardEntities();
+
+#ifdef _DEBUG
+	CBaseEntity *pEnt = 
+#endif
+		CBaseEntity::Create( "portalmp_gamerules", vec3_origin, vec3_angle );
+	Assert( pEnt );
+#endif
+}
+
+//=========================================================
+// FlWeaponRespawnTime - what is the time in the future
+// at which this weapon may spawn?
+//=========================================================
+float CPortalMPGameRules::FlWeaponRespawnTime( CBaseCombatWeapon *pWeapon )
+{
+#ifndef CLIENT_DLL
+	if ( weaponstay.GetInt() > 0 )
+	{
+		// make sure it's only certain weapons
+		if ( !(pWeapon->GetWeaponFlags() & ITEM_FLAG_LIMITINWORLD) )
+		{
+			return 0;		// weapon respawns almost instantly
+		}
+	}
+
+	return sv_hl2mp_weapon_respawn_time.GetFloat();
+#endif
+
+	return 0;		// weapon respawns almost instantly
+}
+
+
+bool CPortalMPGameRules::IsIntermission( void )
+{
+#ifndef CLIENT_DLL
+	return m_flIntermissionEndTime > gpGlobals->curtime;
+#endif
+
+	return false;
+}
+
+void CPortalMPGameRules::PlayerKilled( CBasePlayer *pVictim, const CTakeDamageInfo &info )
+{
+#ifndef CLIENT_DLL
+	if ( IsIntermission() )
+		return;
+	BaseClass::PlayerKilled( pVictim, info );
+#endif
+}
+
+
+void CPortalMPGameRules::Think( void )
+{
+
+#ifndef CLIENT_DLL
+
+	CGameRules::Think();
+
+	if ( g_fGameOver )   // someone else quit the game already
+	{
+		// check to see if we should change levels now
+		if ( m_flIntermissionEndTime < gpGlobals->curtime )
+		{
+			ChangeLevel(); // intermission is over
+		}
+
+		return;
+	}
+
+	//	float flTimeLimit = mp_timelimit.GetFloat() * 60;
+	float flFragLimit = fraglimit.GetFloat();
+
+	if ( GetMapRemainingTime() < 0 )
+	{
+		GoToIntermission();
+		return;
+	}
+
+	if ( flFragLimit )
+	{
+		if( IsTeamplay() == true )
+		{
+			CTeam *pCombine = g_Teams[TEAM_COMBINE];
+			CTeam *pRebels = g_Teams[TEAM_REBELS];
+
+			if ( pCombine->GetScore() >= flFragLimit || pRebels->GetScore() >= flFragLimit )
+			{
+				GoToIntermission();
+				return;
+			}
+		}
+		else
+		{
+			// check if any player is over the frag limit
+			for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+			{
+				CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
+
+				if ( pPlayer && pPlayer->FragCount() >= flFragLimit )
+				{
+					GoToIntermission();
+					return;
+				}
+			}
+		}
+	}
+
+	if ( gpGlobals->curtime > m_tmNextPeriodicThink )
+	{		
+		CheckAllPlayersReady();
+		CheckRestartGame();
+		m_tmNextPeriodicThink = gpGlobals->curtime + 1.0;
+	}
+
+	if ( m_flRestartGameTime > 0.0f && m_flRestartGameTime <= gpGlobals->curtime )
+	{
+		RestartGame();
+	}
+
+	if( m_bAwaitingReadyRestart && m_bHeardAllPlayersReady )
+	{
+		UTIL_ClientPrintAll( HUD_PRINTCENTER, "All players ready. Game will restart in 5 seconds" );
+		UTIL_ClientPrintAll( HUD_PRINTCONSOLE, "All players ready. Game will restart in 5 seconds" );
+
+		m_flRestartGameTime = gpGlobals->curtime + 5;
+		m_bAwaitingReadyRestart = false;
+	}
+
+	ManageObjectRelocation();
+
+#endif
+}
+
+void CPortalMPGameRules::GoToIntermission( void )
+{
+#ifndef CLIENT_DLL
+	if ( g_fGameOver )
+		return;
+
+	g_fGameOver = true;
+
+	m_flIntermissionEndTime = gpGlobals->curtime + mp_chattime.GetInt();
+
+	for ( int i = 0; i < MAX_PLAYERS; i++ )
+	{
+		CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
+
+		if ( !pPlayer )
+			continue;
+
+		pPlayer->ShowViewPortPanel( PANEL_SCOREBOARD );
+		pPlayer->AddFlag( FL_FROZEN );
+	}
+#endif
+
+}
+
+bool CPortalMPGameRules::CheckGameOver()
+{
+#ifndef CLIENT_DLL
+	if ( g_fGameOver )   // someone else quit the game already
+	{
+		// check to see if we should change levels now
+		if ( m_flIntermissionEndTime < gpGlobals->curtime )
+		{
+			ChangeLevel(); // intermission is over			
+		}
+
+		return true;
+	}
+#endif
+
+	return false;
+}
+
+// when we are within this close to running out of entities,  items 
+// marked with the ITEM_FLAG_LIMITINWORLD will delay their respawn
+#define ENTITY_INTOLERANCE	100
+
+//=========================================================
+// FlWeaponRespawnTime - Returns 0 if the weapon can respawn 
+// now,  otherwise it returns the time at which it can try
+// to spawn again.
+//=========================================================
+float CPortalMPGameRules::FlWeaponTryRespawn( CBaseCombatWeapon *pWeapon )
+{
+#ifndef CLIENT_DLL
+	if ( pWeapon && (pWeapon->GetWeaponFlags() & ITEM_FLAG_LIMITINWORLD) )
+	{
+		if ( gEntList.NumberOfEntities() < (gpGlobals->maxEntities - ENTITY_INTOLERANCE) )
+			return 0;
+
+		// we're past the entity tolerance level,  so delay the respawn
+		return FlWeaponRespawnTime( pWeapon );
+	}
+#endif
+	return 0;
+}
+
+//=========================================================
+// VecWeaponRespawnSpot - where should this weapon spawn?
+// Some game variations may choose to randomize spawn locations
+//=========================================================
+Vector CPortalMPGameRules::VecWeaponRespawnSpot( CBaseCombatWeapon *pWeapon )
+{
+#pragma message( __FILE__ "(" __LINE__AS_STRING ") : warning custom: Disabled weapon respawn location code" )
+#if 0
+#ifndef CLIENT_DLL
+	CWeaponHL2MPBase *pHL2Weapon = dynamic_cast< CWeaponHL2MPBase*>( pWeapon );
+
+	if ( pHL2Weapon )
+	{
+		return pHL2Weapon->GetOriginalSpawnOrigin();
+	}
+#endif
+#endif
+
+	return pWeapon->GetAbsOrigin();
+}
+
+#ifndef CLIENT_DLL
+
+CItem* IsManagedObjectAnItem( CBaseEntity *pObject )
+{
+	return dynamic_cast< CItem*>( pObject );
+}
+
+CWeaponPortalBase* IsManagedObjectAWeapon( CBaseEntity *pObject )
+{
+	return dynamic_cast<CWeaponPortalBase*>( pObject );
+}
+
+bool GetObjectsOriginalParameters( CBaseEntity *pObject, Vector &vOriginalOrigin, QAngle &vOriginalAngles )
+{
+	if ( CItem *pItem = IsManagedObjectAnItem( pObject ) )
+	{
+#pragma message( __FILE__ "(" __LINE__AS_STRING ") : warning custom: Disabled rest time code" )
+#if 0
+		if ( pItem->m_flNextResetCheckTime > gpGlobals->curtime )
+			return false;
+#endif
+		vOriginalOrigin = pItem->GetOriginalSpawnOrigin();
+		vOriginalAngles = pItem->GetOriginalSpawnAngles();
+
+#if 0
+		pItem->m_flNextResetCheckTime = gpGlobals->curtime + sv_hl2mp_item_respawn_time.GetFloat();
+#endif
+		return true;
+	}
+	else if ( CWeaponPortalBase *pWeapon = IsManagedObjectAWeapon( pObject )) 
+	{
+		if ( pWeapon->m_flNextResetCheckTime > gpGlobals->curtime )
+			return false;
+
+		vOriginalOrigin = pWeapon->GetOriginalSpawnOrigin();
+		vOriginalAngles = pWeapon->GetOriginalSpawnAngles();
+
+		pWeapon->m_flNextResetCheckTime = gpGlobals->curtime + sv_hl2mp_weapon_respawn_time.GetFloat();
+		return true;
+	}
+
+	return false;
+}
+
+void CPortalMPGameRules::ManageObjectRelocation( void )
+{
+	int iTotal = m_hRespawnableItemsAndWeapons.Count();
+
+	if ( iTotal > 0 )
+	{
+		for ( int i = 0; i < iTotal; i++ )
+		{
+			CBaseEntity *pObject = m_hRespawnableItemsAndWeapons[i].Get();
+
+			if ( pObject )
+			{
+				Vector vSpawOrigin;
+				QAngle vSpawnAngles;
+
+				if ( GetObjectsOriginalParameters( pObject, vSpawOrigin, vSpawnAngles ) == true )
+				{
+					float flDistanceFromSpawn = (pObject->GetAbsOrigin() - vSpawOrigin ).Length();
+
+					if ( flDistanceFromSpawn > WEAPON_MAX_DISTANCE_FROM_SPAWN )
+					{
+						bool shouldReset = false;
+						IPhysicsObject *pPhysics = pObject->VPhysicsGetObject();
+
+						if ( pPhysics )
+						{
+							shouldReset = pPhysics->IsAsleep();
+						}
+						else
+						{
+							shouldReset = (pObject->GetFlags() & FL_ONGROUND) ? true : false;
+						}
+
+						if ( shouldReset )
+						{
+							pObject->Teleport( &vSpawOrigin, &vSpawnAngles, NULL );
+							pObject->EmitSound( "AlyxEmp.Charge" );
+
+							IPhysicsObject *pPhys = pObject->VPhysicsGetObject();
+
+							if ( pPhys )
+							{
+								pPhys->Wake();
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+//=========================================================
+//AddLevelDesignerPlacedWeapon
+//=========================================================
+void CPortalMPGameRules::AddLevelDesignerPlacedObject( CBaseEntity *pEntity )
+{
+	if ( m_hRespawnableItemsAndWeapons.Find( pEntity ) == -1 )
+	{
+		m_hRespawnableItemsAndWeapons.AddToTail( pEntity );
+	}
+}
+
+//=========================================================
+//RemoveLevelDesignerPlacedWeapon
+//=========================================================
+void CPortalMPGameRules::RemoveLevelDesignerPlacedObject( CBaseEntity *pEntity )
+{
+	if ( m_hRespawnableItemsAndWeapons.Find( pEntity ) != -1 )
+	{
+		m_hRespawnableItemsAndWeapons.FindAndRemove( pEntity );
+	}
+}
+
+//=========================================================
+// Where should this item respawn?
+// Some game variations may choose to randomize spawn locations
+//=========================================================
+Vector CPortalMPGameRules::VecItemRespawnSpot( CItem *pItem )
+{
+	return pItem->GetOriginalSpawnOrigin();
+}
+
+//=========================================================
+// What angles should this item use to respawn?
+//=========================================================
+QAngle CPortalMPGameRules::VecItemRespawnAngles( CItem *pItem )
+{
+	return pItem->GetOriginalSpawnAngles();
+}
+
+//=========================================================
+// At what time in the future may this Item respawn?
+//=========================================================
+float CPortalMPGameRules::FlItemRespawnTime( CItem *pItem )
+{
+	return sv_hl2mp_item_respawn_time.GetFloat();
+}
+
+
+//=========================================================
+// CanHaveWeapon - returns false if the player is not allowed
+// to pick up this weapon
+//=========================================================
+bool CPortalMPGameRules::CanHavePlayerItem( CBasePlayer *pPlayer, CBaseCombatWeapon *pItem )
+{
+	if ( weaponstay.GetInt() > 0 )
+	{
+		if ( pPlayer->Weapon_OwnsThisType( pItem->GetClassname(), pItem->GetSubType() ) )
+			return false;
+	}
+
+	return BaseClass::CanHavePlayerItem( pPlayer, pItem );
+}
+
+#endif
+
+//=========================================================
+// WeaponShouldRespawn - any conditions inhibiting the
+// respawning of this weapon?
+//=========================================================
+int CPortalMPGameRules::WeaponShouldRespawn( CBaseCombatWeapon *pWeapon )
+{
+#ifndef CLIENT_DLL
+	if ( pWeapon->HasSpawnFlags( SF_NORESPAWN ) )
+	{
+		return GR_WEAPON_RESPAWN_NO;
+	}
+#endif
+
+	return GR_WEAPON_RESPAWN_YES;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Player has just left the game
+//-----------------------------------------------------------------------------
+void CPortalMPGameRules::ClientDisconnected( edict_t *pClient )
+{
+#ifndef CLIENT_DLL
+	// Msg( "CLIENT DISCONNECTED, REMOVING FROM TEAM.\n" );
+
+	CBasePlayer *pPlayer = (CBasePlayer *)CBaseEntity::Instance( pClient );
+	if ( pPlayer )
+	{
+		// Remove the player from his team
+		if ( pPlayer->GetTeam() )
+		{
+			pPlayer->GetTeam()->RemovePlayer( pPlayer );
+		}
+	}
+
+	BaseClass::ClientDisconnected( pClient );
+
+#endif
+}
+
+
+//=========================================================
+// Deathnotice. 
+//=========================================================
+void CPortalMPGameRules::DeathNotice( CBasePlayer *pVictim, const CTakeDamageInfo &info )
+{
+#ifndef CLIENT_DLL
+	// Work out what killed the player, and send a message to all clients about it
+	const char *killer_weapon_name = "world";		// by default, the player is killed by the world
+	int killer_ID = 0;
+
+	// Find the killer & the scorer
+	CBaseEntity *pInflictor = info.GetInflictor();
+	CBaseEntity *pKiller = info.GetAttacker();
+	CBasePlayer *pScorer = GetDeathScorer( pKiller, pInflictor );
+
+	// Custom kill type?
+	if ( info.GetDamageCustom() )
+	{
+		killer_weapon_name = GetDamageCustomString( info );
+		if ( pScorer )
+		{
+			killer_ID = pScorer->GetUserID();
+		}
+	}
+	else
+	{
+		// Is the killer a client?
+		if ( pScorer )
+		{
+			killer_ID = pScorer->GetUserID();
+
+			if ( pInflictor )
+			{
+				if ( pInflictor == pScorer )
+				{
+					// If the inflictor is the killer,  then it must be their current weapon doing the damage
+					if ( pScorer->GetActiveWeapon() )
+					{
+						killer_weapon_name = pScorer->GetActiveWeapon()->GetClassname();
+					}
+				}
+				else
+				{
+					killer_weapon_name = pInflictor->GetClassname();  // it's just that easy
+				}
+			}
+		}
+		else
+		{
+			killer_weapon_name = pInflictor->GetClassname();
+		}
+
+		// strip the NPC_* or weapon_* from the inflictor's classname
+		if ( strncmp( killer_weapon_name, "weapon_", 7 ) == 0 )
+		{
+			killer_weapon_name += 7;
+		}
+		else if ( strncmp( killer_weapon_name, "npc_", 4 ) == 0 )
+		{
+			killer_weapon_name += 4;
+		}
+		else if ( strncmp( killer_weapon_name, "func_", 5 ) == 0 )
+		{
+			killer_weapon_name += 5;
+		}
+		else if ( strstr( killer_weapon_name, "physics" ) )
+		{
+			killer_weapon_name = "physics";
+		}
+
+		if ( strcmp( killer_weapon_name, "prop_combine_ball" ) == 0 )
+		{
+			killer_weapon_name = "combine_ball";
+		}
+		else if ( strcmp( killer_weapon_name, "grenade_ar2" ) == 0 )
+		{
+			killer_weapon_name = "smg1_grenade";
+		}
+		else if ( strcmp( killer_weapon_name, "satchel" ) == 0 || strcmp( killer_weapon_name, "tripmine" ) == 0)
+		{
+			killer_weapon_name = "slam";
+		}
+
+
+	}
+
+	IGameEvent *event = gameeventmanager->CreateEvent( "player_death" );
+	if( event )
+	{
+		event->SetInt("userid", pVictim->GetUserID() );
+		event->SetInt("attacker", killer_ID );
+		event->SetString("weapon", killer_weapon_name );
+		event->SetInt( "priority", 7 );
+		gameeventmanager->FireEvent( event );
+	}
+#endif
+
+}
+
+void CPortalMPGameRules::ClientSettingsChanged( CBasePlayer *pPlayer )
+{
+#ifndef CLIENT_DLL
+
+	CPortal_Player *pPortalPlayer = ToPortalPlayer( pPlayer );
+	//CHL2MP_Player *pHL2Player = ToHL2MPPlayer( pPlayer );
+
+	if ( pPortalPlayer == NULL )
+		return;
+
+	const char *pCurrentModel = modelinfo->GetModelName( pPlayer->GetModel() );
+	const char *szModelName = engine->GetClientConVarValue( engine->IndexOfEdict( pPlayer->edict() ), "cl_playermodel" );
+
+	//If we're different.
+	if ( stricmp( szModelName, pCurrentModel ) )
+	{
+		//Too soon, set the cvar back to what it was.
+		//Note: this will make this function be called again
+		//but since our models will match it'll just skip this whole dealio.
+#pragma message( __FILE__ "(" __LINE__AS_STRING ") : warning custom: Disabled model change code" )
+#if 0
+		if ( pPortalPlayer->GetNextModelChangeTime() >= gpGlobals->curtime )
+		{
+			char szReturnString[512];
+
+			Q_snprintf( szReturnString, sizeof (szReturnString ), "cl_playermodel %s\n", pCurrentModel );
+			engine->ClientCommand ( pPlayer->edict(), szReturnString );
+
+			Q_snprintf( szReturnString, sizeof( szReturnString ), "Please wait %d more seconds before trying to switch.\n", (int)(pPlayer->GetNextModelChangeTime() - gpGlobals->curtime) );
+			ClientPrint( pPlayer, HUD_PRINTTALK, szReturnString );
+			return;
+		}
+#endif
+
+		if ( PortalMPGameRules()->IsTeamplay() == false )
+		{
+			pPortalPlayer->SetPlayerModel();
+
+			const char *pszCurrentModelName = modelinfo->GetModelName( pPlayer->GetModel() );
+
+			char szReturnString[128];
+			Q_snprintf( szReturnString, sizeof( szReturnString ), "Your player model is: %s\n", pszCurrentModelName );
+
+			ClientPrint( pPlayer, HUD_PRINTTALK, szReturnString );
+		}
+		else
+		{
+			if ( Q_stristr( szModelName, "models/human") )
+			{
+				pPlayer->ChangeTeam( TEAM_REBELS );
+			}
+			else
+			{
+				pPlayer->ChangeTeam( TEAM_COMBINE );
+			}
+		}
+	}
+	if ( sv_report_client_settings.GetInt() == 1 )
+	{
+		UTIL_LogPrintf( "\"%s\" cl_cmdrate = \"%s\"\n", pPlayer->GetPlayerName(), engine->GetClientConVarValue( pPlayer->entindex(), "cl_cmdrate" ));
+	}
+
+	BaseClass::ClientSettingsChanged( pPlayer );
+#endif
+
+}
+
+int CPortalMPGameRules::PlayerRelationship( CBaseEntity *pPlayer, CBaseEntity *pTarget )
+{
+#ifndef CLIENT_DLL
+	// half life multiplay has a simple concept of Player Relationships.
+	// you are either on another player's team, or you are not.
+	if ( !pPlayer || !pTarget || !pTarget->IsPlayer() || IsTeamplay() == false )
+		return GR_NOTTEAMMATE;
+
+	if ( (*GetTeamID(pPlayer) != '\0') && (*GetTeamID(pTarget) != '\0') && !stricmp( GetTeamID(pPlayer), GetTeamID(pTarget) ) )
+	{
+		return GR_TEAMMATE;
+	}
+#endif
+
+	return GR_NOTTEAMMATE;
+}
+
+const char *CPortalMPGameRules::GetGameDescription( void )
+{
+	return "PMP Test";
+} 
+
+
+float CPortalMPGameRules::GetMapRemainingTime()
+{
+	// if timelimit is disabled, return 0
+	if ( mp_timelimit.GetInt() <= 0 )
+		return 0;
+
+	// timelimit is in minutes
+
+	float timeleft = (m_flGameStartTime + mp_timelimit.GetInt() * 60.0f ) - gpGlobals->curtime;
+
+	return timeleft;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPortalMPGameRules::Precache( void )
+{
+	CBaseEntity::PrecacheScriptSound( "AlyxEmp.Charge" );
+}
+
+bool CPortalMPGameRules::ShouldCollide( int collisionGroup0, int collisionGroup1 )
+{
+	if ( collisionGroup0 > collisionGroup1 )
+	{
+		// swap so that lowest is always first
+		swap(collisionGroup0,collisionGroup1);
+	}
+
+	if ( (collisionGroup0 == COLLISION_GROUP_PLAYER || collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT) &&
+		collisionGroup1 == COLLISION_GROUP_WEAPON )
+	{
+		return false;
+	}
+
+	return BaseClass::ShouldCollide( collisionGroup0, collisionGroup1 ); 
+
+}
+
+bool CPortalMPGameRules::ClientCommand( CBaseEntity *pEdict, const CCommand &args )
+{
+
+#ifndef CLIENT_DLL
+	if( BaseClass::ClientCommand( pEdict, args ) )
+		return true;
+
+
+	CBasePlayer *pPlayer = (CBasePlayer *) pEdict;
+
+	if ( pPlayer->ClientCommand( args ) )
+		return true;
+#endif
+
+	return false;
+}
+
+// shared ammo definition
+// JAY: Trying to make a more physical bullet response
+#define BULLET_MASS_GRAINS_TO_LB(grains)	(0.002285*(grains)/16.0f)
+#define BULLET_MASS_GRAINS_TO_KG(grains)	lbs2kg(BULLET_MASS_GRAINS_TO_LB(grains))
+
+// exaggerate all of the forces, but use real numbers to keep them consistent
+#define BULLET_IMPULSE_EXAGGERATION			3.5
+// convert a velocity in ft/sec and a mass in grains to an impulse in kg in/s
+#define BULLET_IMPULSE(grains, ftpersec)	((ftpersec)*12*BULLET_MASS_GRAINS_TO_KG(grains)*BULLET_IMPULSE_EXAGGERATION)
+
+
+CAmmoDef *GetAmmoDef()
+{
+	static CAmmoDef def;
+	static bool bInitted = false;
+
+	if ( !bInitted )
+	{
+		bInitted = true;
+
+		def.AddAmmoType("AR2",				DMG_BULLET,					TRACER_LINE_AND_WHIZ,	"sk_plr_dmg_ar2",			"sk_npc_dmg_ar2",			"sk_max_ar2",			BULLET_IMPULSE(200, 1225), 0 );
+		def.AddAmmoType("AlyxGun",			DMG_BULLET,					TRACER_LINE,			"sk_plr_dmg_alyxgun",		"sk_npc_dmg_alyxgun",		"sk_max_alyxgun",		BULLET_IMPULSE(200, 1225), 0 );
+		def.AddAmmoType("Pistol",			DMG_BULLET,					TRACER_LINE_AND_WHIZ,	"sk_plr_dmg_pistol",		"sk_npc_dmg_pistol",		"sk_max_pistol",		BULLET_IMPULSE(200, 1225), 0 );
+		def.AddAmmoType("SMG1",				DMG_BULLET,					TRACER_LINE_AND_WHIZ,	"sk_plr_dmg_smg1",			"sk_npc_dmg_smg1",			"sk_max_smg1",			BULLET_IMPULSE(200, 1225), 0 );
+		def.AddAmmoType("357",				DMG_BULLET,					TRACER_LINE_AND_WHIZ,	"sk_plr_dmg_357",			"sk_npc_dmg_357",			"sk_max_357",			BULLET_IMPULSE(800, 5000), 0 );
+		def.AddAmmoType("XBowBolt",			DMG_BULLET,					TRACER_LINE,			"sk_plr_dmg_crossbow",		"sk_npc_dmg_crossbow",		"sk_max_crossbow",		BULLET_IMPULSE(800, 8000), 0 );
+
+		def.AddAmmoType("Buckshot",			DMG_BULLET | DMG_BUCKSHOT,	TRACER_LINE,			"sk_plr_dmg_buckshot",		"sk_npc_dmg_buckshot",		"sk_max_buckshot",		BULLET_IMPULSE(400, 1200), 0 );
+		def.AddAmmoType("RPG_Round",		DMG_BURN,					TRACER_NONE,			"sk_plr_dmg_rpg_round",		"sk_npc_dmg_rpg_round",		"sk_max_rpg_round",		0, 0 );
+		def.AddAmmoType("SMG1_Grenade",		DMG_BURN,					TRACER_NONE,			"sk_plr_dmg_smg1_grenade",	"sk_npc_dmg_smg1_grenade",	"sk_max_smg1_grenade",	0, 0 );
+		def.AddAmmoType("SniperRound",		DMG_BULLET | DMG_SNIPER,	TRACER_NONE,			"sk_plr_dmg_sniper_round",	"sk_npc_dmg_sniper_round",	"sk_max_sniper_round",	BULLET_IMPULSE(650, 6000), 0 );
+		def.AddAmmoType("SniperPenetratedRound", DMG_BULLET | DMG_SNIPER, TRACER_NONE,			"sk_dmg_sniper_penetrate_plr", "sk_dmg_sniper_penetrate_npc", "sk_max_sniper_round", BULLET_IMPULSE(150, 6000), 0 );
+		def.AddAmmoType("Grenade",			DMG_BURN,					TRACER_NONE,			"sk_plr_dmg_grenade",		"sk_npc_dmg_grenade",		"sk_max_grenade",		0, 0);
+		def.AddAmmoType("Thumper",			DMG_SONIC,					TRACER_NONE,			10, 10, 2, 0, 0 );
+		def.AddAmmoType("Gravity",			DMG_CLUB,					TRACER_NONE,			0,	0, 8, 0, 0 );
+		def.AddAmmoType("Battery",			DMG_CLUB,					TRACER_NONE,			NULL, NULL, NULL, 0, 0 );
+		def.AddAmmoType("GaussEnergy",		DMG_SHOCK,					TRACER_NONE,			"sk_jeep_gauss_damage",		"sk_jeep_gauss_damage", "sk_max_gauss_round", BULLET_IMPULSE(650, 8000), 0 ); // hit like a 10kg weight at 400 in/s
+		def.AddAmmoType("CombineCannon",	DMG_BULLET,					TRACER_LINE,			"sk_npc_dmg_gunship_to_plr", "sk_npc_dmg_gunship", NULL, 1.5 * 750 * 12, 0 ); // hit like a 1.5kg weight at 750 ft/s
+		def.AddAmmoType("AirboatGun",		DMG_AIRBOAT,				TRACER_LINE,			"sk_plr_dmg_airboat",		"sk_npc_dmg_airboat",		NULL,					BULLET_IMPULSE(10, 600), 0 );
+		def.AddAmmoType("StriderMinigun",	DMG_BULLET,					TRACER_LINE,			5, 5, 15, 1.0 * 750 * 12, AMMO_FORCE_DROP_IF_CARRIED ); // hit like a 1.0kg weight at 750 ft/s
+		def.AddAmmoType("HelicopterGun",	DMG_BULLET,					TRACER_LINE_AND_WHIZ,	"sk_npc_dmg_helicopter_to_plr", "sk_npc_dmg_helicopter",	"sk_max_smg1",	BULLET_IMPULSE(400, 1225), AMMO_FORCE_DROP_IF_CARRIED | AMMO_INTERPRET_PLRDAMAGE_AS_DAMAGE_TO_PLAYER );
+		def.AddAmmoType("AR2AltFire",		DMG_DISSOLVE,				TRACER_NONE,			0, 0, "sk_max_ar2_altfire", 0, 0 );
+#ifdef HL2_EPISODIC
+		def.AddAmmoType("Hopwire",			DMG_BLAST,					TRACER_NONE,			"sk_plr_dmg_grenade",		"sk_npc_dmg_grenade",		"sk_max_hopwire",		0, 0);
+		def.AddAmmoType("HunterGun",		DMG_BULLET,					TRACER_LINE,			"sk_hunter_dmg",			"sk_hunter_dmg",			"sk_hunter_max_round",	BULLET_IMPULSE(200, 1225), 0 );
+		def.AddAmmoType("CombineHeavyCannon",	DMG_BLAST,				TRACER_LINE,			40,	40, NULL, 1.5 * 750 * 12, AMMO_FORCE_DROP_IF_CARRIED ); // hit like a 100 kg weight at 750 ft/s
+#endif // HL2_EPISODIC
+	}
+
+	return &def;
+}
+
+#ifdef CLIENT_DLL
+
+ConVar cl_autowepswitch(
+						"cl_autowepswitch",
+						"1",
+						FCVAR_ARCHIVE | FCVAR_USERINFO,
+						"Automatically switch to picked up weapons (if more powerful)" );
+
+#else
+
+
+bool CPortalMPGameRules::FShouldSwitchWeapon( CBasePlayer *pPlayer, CBaseCombatWeapon *pWeapon )
+{		
+	if ( pPlayer->GetActiveWeapon() && pPlayer->IsNetClient() )
+	{
+		// Player has an active item, so let's check cl_autowepswitch.
+		const char *cl_autowepswitch = engine->GetClientConVarValue( engine->IndexOfEdict( pPlayer->edict() ), "cl_autowepswitch" );
+		if ( cl_autowepswitch && atoi( cl_autowepswitch ) <= 0 )
+		{
+			return false;
+		}
+	}
+
+	return BaseClass::FShouldSwitchWeapon( pPlayer, pWeapon );
+}
+
+#endif
+
+#ifndef CLIENT_DLL
+
+//-----------------------------------------------------------------------------
+// Purpose: Damage (applied per second) value of the npc_laser_turret
+//-----------------------------------------------------------------------------
+float CPortalMPGameRules::GetLaserTurretDamage( void )
+{
+	switch( GetSkillLevel() )
+	{
+	case SKILL_EASY:
+		return 120.0f;
+
+	case SKILL_MEDIUM:
+		return 200.0f;
+
+	case SKILL_HARD:
+		return 200.0f;
+
+	default:
+		return 100.0f;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Movement speed of the turret. 
+//-----------------------------------------------------------------------------
+float CPortalMPGameRules::GetLaserTurretMoveSpeed( void )
+{
+	switch( GetSkillLevel() )
+	{
+	case SKILL_EASY:
+		return 0.6f;
+
+	case SKILL_MEDIUM:
+		return 0.8f;
+
+	case SKILL_HARD:
+		return 1.0f;
+
+	default:
+		return 0.7f;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Damage value of the npc_rocket_turret
+//-----------------------------------------------------------------------------
+float CPortalMPGameRules::GetRocketTurretDamage( void )
+{
+	switch( GetSkillLevel() )
+	{
+	case SKILL_EASY:
+		return 120.0f;
+
+	case SKILL_MEDIUM:
+		return 200.0f;
+
+	case SKILL_HARD:
+		return 200.0f;
+
+	default:
+		return 100.0f;
+	}
+}
+
+
+bool FindInList( const char **pStrings, const char *pToFind );
+
+void CPortalMPGameRules::RestartGame()
+{
+	// bounds check
+	if ( mp_timelimit.GetInt() < 0 )
+	{
+		mp_timelimit.SetValue( 0 );
+	}
+	m_flGameStartTime = gpGlobals->curtime;
+	if ( !IsFinite( m_flGameStartTime.Get() ) )
+	{
+		Warning( "Trying to set a NaN game start time\n" );
+		m_flGameStartTime.GetForModify() = 0.0f;
+	}
+
+	CleanUpMap();
+
+	// now respawn all players
+	for (int i = 1; i <= gpGlobals->maxClients; i++ )
+	{
+		CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
+
+		if ( !pPlayer )
+			continue;
+
+		if ( pPlayer->GetActiveWeapon() )
+		{
+			pPlayer->GetActiveWeapon()->Holster();
+		}
+		pPlayer->RemoveAllItems( true );
+		respawn( pPlayer, false );
+#pragma message( __FILE__ "(" __LINE__AS_STRING ") : warning custom: Disabled player reset" )
+#if 0
+		pPlayer->Reset();
+#endif
+	}
+
+	// Respawn entities (glass, doors, etc..)
+
+	CTeam *pRebels = GetGlobalTeam( TEAM_REBELS );
+	CTeam *pCombine = GetGlobalTeam( TEAM_COMBINE );
+
+	if ( pRebels )
+	{
+		pRebels->SetScore( 0 );
+	}
+
+	if ( pCombine )
+	{
+		pCombine->SetScore( 0 );
+	}
+
+	m_flIntermissionEndTime = 0;
+	m_flRestartGameTime = 0.0;		
+	m_bCompleteReset = false;
+
+	IGameEvent * event = gameeventmanager->CreateEvent( "round_start" );
+	if ( event )
+	{
+		event->SetInt("fraglimit", 0 );
+		event->SetInt( "priority", 6 ); // HLTV event priority, not transmitted
+
+		event->SetString("objective","DEATHMATCH");
+
+		gameeventmanager->FireEvent( event );
+	}
+}
+
+void CPortalMPGameRules::CleanUpMap()
+{
+	// Recreate all the map entities from the map data (preserving their indices),
+	// then remove everything else except the players.
+
+	// Get rid of all entities except players.
+	CBaseEntity *pCur = gEntList.FirstEnt();
+	while ( pCur )
+	{
+		CBaseCombatWeapon *pWeapon = dynamic_cast< CBaseCombatWeapon* >( pCur );
+		// Weapons with owners don't want to be removed..
+		if ( pWeapon )
+		{
+			if ( !pWeapon->GetOwner() || !pWeapon->GetOwner()->IsPlayer() )
+			{
+				UTIL_Remove( pCur );
+			}
+		}
+		// remove entities that has to be restored on roundrestart (breakables etc)
+		else if ( !FindInList( s_PreserveEnts, pCur->GetClassname() ) )
+		{
+			UTIL_Remove( pCur );
+		}
+
+		pCur = gEntList.NextEnt( pCur );
+	}
+
+	// Really remove the entities so we can have access to their slots below.
+	gEntList.CleanupDeleteList();
+
+	// Cancel all queued events, in case a func_bomb_target fired some delayed outputs that
+	// could kill respawning CTs
+	g_EventQueue.Clear();
+
+#pragma message( __FILE__ "(" __LINE__AS_STRING ") : warning custom: Disabled entity parsing" )
+#if 0
+	// Now reload the map entities.
+	class CHL2MPMapEntityFilter : public IMapEntityFilter
+	{
+	public:
+		virtual bool ShouldCreateEntity( const char *pClassname )
+		{
+			// Don't recreate the preserved entities.
+			if ( !FindInList( s_PreserveEnts, pClassname ) )
+			{
+				return true;
+			}
+			else
+			{
+				// Increment our iterator since it's not going to call CreateNextEntity for this ent.
+				if ( m_iIterator != g_MapEntityRefs.InvalidIndex() )
+					m_iIterator = g_MapEntityRefs.Next( m_iIterator );
+
+				return false;
+			}
+		}
+
+
+		virtual CBaseEntity* CreateNextEntity( const char *pClassname )
+		{
+			if ( m_iIterator == g_MapEntityRefs.InvalidIndex() )
+			{
+				// This shouldn't be possible. When we loaded the map, it should have used 
+				// CCSMapLoadEntityFilter, which should have built the g_MapEntityRefs list
+				// with the same list of entities we're referring to here.
+				Assert( false );
+				return NULL;
+			}
+			else
+			{
+				CMapEntityRef &ref = g_MapEntityRefs[m_iIterator];
+				m_iIterator = g_MapEntityRefs.Next( m_iIterator );	// Seek to the next entity.
+
+				if ( ref.m_iEdict == -1 || engine->PEntityOfEntIndex( ref.m_iEdict ) )
+				{
+					// Doh! The entity was delete and its slot was reused.
+					// Just use any old edict slot. This case sucks because we lose the baseline.
+					return CreateEntityByName( pClassname );
+				}
+				else
+				{
+					// Cool, the slot where this entity was is free again (most likely, the entity was 
+					// freed above). Now create an entity with this specific index.
+					return CreateEntityByName( pClassname, ref.m_iEdict );
+				}
+			}
+		}
+
+	public:
+		int m_iIterator; // Iterator into g_MapEntityRefs.
+	};
+
+	CHL2MPMapEntityFilter filter;
+	filter.m_iIterator = g_MapEntityRefs.Head();
+
+	// DO NOT CALL SPAWN ON info_node ENTITIES!
+
+	MapEntity_ParseAllEntities( engine->GetMapEntitiesString(), &filter, true );
+#endif
+}
+
+void CPortalMPGameRules::CheckRestartGame( void )
+{
+	// Restart the game if specified by the server
+	int iRestartDelay = mp_restartgame.GetInt();
+
+	if ( iRestartDelay > 0 )
+	{
+		if ( iRestartDelay > 60 )
+			iRestartDelay = 60;
+
+
+		// let the players know
+		char strRestartDelay[64];
+		Q_snprintf( strRestartDelay, sizeof( strRestartDelay ), "%d", iRestartDelay );
+		UTIL_ClientPrintAll( HUD_PRINTCENTER, "Game will restart in %s1 %s2", strRestartDelay, iRestartDelay == 1 ? "SECOND" : "SECONDS" );
+		UTIL_ClientPrintAll( HUD_PRINTCONSOLE, "Game will restart in %s1 %s2", strRestartDelay, iRestartDelay == 1 ? "SECOND" : "SECONDS" );
+
+		m_flRestartGameTime = gpGlobals->curtime + iRestartDelay;
+		m_bCompleteReset = true;
+		mp_restartgame.SetValue( 0 );
+	}
+
+#pragma message( __FILE__ "(" __LINE__AS_STRING ") : warning custom: Disabled ready restart" )
+#if 0
+	if( mp_readyrestart.GetBool() )
+	{
+		m_bAwaitingReadyRestart = true;
+		m_bHeardAllPlayersReady = false;
+
+
+		const char *pszReadyString = mp_ready_signal.GetString();
+
+
+		// Don't let them put anything malicious in there
+		if( pszReadyString == NULL || Q_strlen(pszReadyString) > 16 )
+		{
+			pszReadyString = "ready";
+		}
+
+		IGameEvent *event = gameeventmanager->CreateEvent( "hl2mp_ready_restart" );
+		if ( event )
+			gameeventmanager->FireEvent( event );
+
+		mp_readyrestart.SetValue( 0 );
+
+		// cancel any restart round in progress
+		m_flRestartGameTime = -1;
+	}
+#endif
+}
+
+void CPortalMPGameRules::CheckAllPlayersReady( void )
+{
+#pragma message( __FILE__ "(" __LINE__AS_STRING ") : warning custom: Disabled ready restart" )
+#if 0
+	for (int i = 1; i <= gpGlobals->maxClients; i++ )
+	{
+		CHL2MP_Player *pPlayer = (CHL2MP_Player*) UTIL_PlayerByIndex( i );
+
+		if ( !pPlayer )
+			continue;
+		if ( !pPlayer->IsReady() )
+			return;
+	}
+#endif
+	m_bHeardAllPlayersReady = true;
+}
+
+#endif
\ No newline at end of file