d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
22 Commits
25 Branches
6 Tags
221 MiB
Tree: 7adf2b9612
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '7adf2b9612'
${ noResults }
source-engine/game/shared/portal/portal_mp_gamerules.cpp

1283 lines
35 KiB
Raw Normal View History Unescape

1
5 years ago
//========= 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