//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: The TF Game rules
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "cs_gamerules.h"
#include "cs_ammodef.h"
#include "weapon_csbase.h"
#include "cs_shareddefs.h"
#include "KeyValues.h"
#include "cs_achievement_constants.h"
#include "fmtstr.h"
#ifdef CLIENT_DLL
#include "networkstringtable_clientdll.h"
#include "utlvector.h"
#else
#include "bot.h"
#include "utldict.h"
#include "cs_player.h"
#include "cs_team.h"
#include "cs_gamerules.h"
#include "voice_gamemgr.h"
#include "igamesystem.h"
#include "weapon_c4.h"
#include "mapinfo.h"
#include "shake.h"
#include "mapentities.h"
#include "game.h"
#include "cs_simple_hostage.h"
#include "cs_gameinterface.h"
#include "player_resource.h"
#include "info_view_parameters.h"
#include "cs_bot_manager.h"
#include "cs_bot.h"
#include "eventqueue.h"
#include "fmtstr.h"
#include "teamplayroundbased_gamerules.h"
#include "gameweaponmanager.h"
#include "cs_gamestats.h"
#include "cs_urlretrieveprices.h"
#include "networkstringtable_gamedll.h"
#include "player_resource.h"
#include "cs_player_resource.h"
#if defined( REPLAY_ENABLED )
#include "replay/ireplaysystem.h"
#include "replay/iserverreplaycontext.h"
#include "replay/ireplaysessionrecorder.h"
#endif // REPLAY_ENABLED
#endif
#include "cs_blackmarket.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#ifndef CLIENT_DLL
#define CS_GAME_STATS_UPDATE 79200 //22 hours
#define CS_GAME_STATS_UPDATE_PERIOD 7200 // 2 hours
extern IUploadGameStats *gamestatsuploader;
#if defined( REPLAY_ENABLED )
extern IReplaySystem *g_pReplay;
#endif // REPLAY_ENABLED
#endif
/**
* Player hull & eye position for standing, ducking, etc. This version has a taller
* player height, but goldsrc-compatible collision bounds.
*/
static CViewVectors g_CSViewVectors(
Vector( 0, 0, 64 ), // eye position
Vector(-16, -16, 0 ), // hull min
Vector( 16, 16, 62 ), // hull max
Vector(-16, -16, 0 ), // duck hull min
Vector( 16, 16, 45 ), // duck hull max
Vector( 0, 0, 47 ), // duck view
Vector(-10, -10, -10 ), // observer hull min
Vector( 10, 10, 10 ), // observer hull max
Vector( 0, 0, 14 ) // dead view height
);
#ifndef CLIENT_DLL
LINK_ENTITY_TO_CLASS(info_player_terrorist, CPointEntity);
LINK_ENTITY_TO_CLASS(info_player_counterterrorist,CPointEntity);
LINK_ENTITY_TO_CLASS(info_player_logo,CPointEntity);
#endif
REGISTER_GAMERULES_CLASS( CCSGameRules );
BEGIN_NETWORK_TABLE_NOBASE( CCSGameRules, DT_CSGameRules )
#ifdef CLIENT_DLL
RecvPropBool( RECVINFO( m_bFreezePeriod ) ),
RecvPropInt( RECVINFO( m_iRoundTime ) ),
RecvPropFloat( RECVINFO( m_fRoundStartTime ) ),
RecvPropFloat( RECVINFO( m_flGameStartTime ) ),
RecvPropInt( RECVINFO( m_iHostagesRemaining ) ),
RecvPropBool( RECVINFO( m_bMapHasBombTarget ) ),
RecvPropBool( RECVINFO( m_bMapHasRescueZone ) ),
RecvPropBool( RECVINFO( m_bLogoMap ) ),
RecvPropBool( RECVINFO( m_bBlackMarket ) )
#else
SendPropBool( SENDINFO( m_bFreezePeriod ) ),
SendPropInt( SENDINFO( m_iRoundTime ), 16 ),
SendPropFloat( SENDINFO( m_fRoundStartTime ), 32, SPROP_NOSCALE ),
SendPropFloat( SENDINFO( m_flGameStartTime ), 32, SPROP_NOSCALE ),
SendPropInt( SENDINFO( m_iHostagesRemaining ), 4 ),
SendPropBool( SENDINFO( m_bMapHasBombTarget ) ),
SendPropBool( SENDINFO( m_bMapHasRescueZone ) ),
SendPropBool( SENDINFO( m_bLogoMap ) ),
SendPropBool( SENDINFO( m_bBlackMarket ) )
#endif
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( cs_gamerules, CCSGameRulesProxy );
IMPLEMENT_NETWORKCLASS_ALIASED( CSGameRulesProxy, DT_CSGameRulesProxy )
#ifdef CLIENT_DLL
void RecvProxy_CSGameRules( const RecvProp *pProp, void **pOut, void *pData, int objectID )
{
CCSGameRules *pRules = CSGameRules();
Assert( pRules );
*pOut = pRules;
}
BEGIN_RECV_TABLE( CCSGameRulesProxy, DT_CSGameRulesProxy )
RecvPropDataTable( "cs_gamerules_data", 0, 0, &REFERENCE_RECV_TABLE( DT_CSGameRules ), RecvProxy_CSGameRules )
END_RECV_TABLE()
#else
void* SendProxy_CSGameRules( const SendProp *pProp, const void *pStructBase, const void *pData, CSendProxyRecipients *pRecipients, int objectID )
{
CCSGameRules *pRules = CSGameRules();
Assert( pRules );
return pRules;
}
BEGIN_SEND_TABLE( CCSGameRulesProxy, DT_CSGameRulesProxy )
SendPropDataTable( "cs_gamerules_data", 0, &REFERENCE_SEND_TABLE( DT_CSGameRules ), SendProxy_CSGameRules )
END_SEND_TABLE()
#endif
ConVar ammo_50AE_max( "ammo_50AE_max", "35", FCVAR_REPLICATED );
ConVar ammo_762mm_max( "ammo_762mm_max", "90", FCVAR_REPLICATED );
ConVar ammo_556mm_max( "ammo_556mm_max", "90", FCVAR_REPLICATED );
ConVar ammo_556mm_box_max( "ammo_556mm_box_max", "200", FCVAR_REPLICATED );
ConVar ammo_338mag_max( "ammo_338mag_max", "30", FCVAR_REPLICATED );
ConVar ammo_9mm_max( "ammo_9mm_max", "120", FCVAR_REPLICATED );
ConVar ammo_buckshot_max( "ammo_buckshot_max", "32", FCVAR_REPLICATED );
ConVar ammo_45acp_max( "ammo_45acp_max", "100", FCVAR_REPLICATED );
ConVar ammo_357sig_max( "ammo_357sig_max", "52", FCVAR_REPLICATED );
ConVar ammo_57mm_max( "ammo_57mm_max", "100", FCVAR_REPLICATED );
ConVar ammo_hegrenade_max( "ammo_hegrenade_max", "1", FCVAR_REPLICATED );
ConVar ammo_flashbang_max( "ammo_flashbang_max", "2", FCVAR_REPLICATED );
ConVar ammo_smokegrenade_max( "ammo_smokegrenade_max", "1", FCVAR_REPLICATED );
//ConVar mp_dynamicpricing( "mp_dynamicpricing", "0", FCVAR_REPLICATED, "Enables or Disables the dynamic weapon prices" );
extern ConVar sv_stopspeed;
ConVar mp_buytime(
"mp_buytime",
"1.5",
FCVAR_REPLICATED,
"How many minutes after round start players can buy items for.",
true, 0.25,
false, 0 );
ConVar mp_playerid(
"mp_playerid",
"0",
FCVAR_REPLICATED,
"Controls what information player see in the status bar: 0 all names; 1 team names; 2 no names",
true, 0,
true, 2 );
ConVar mp_playerid_delay(
"mp_playerid_delay",
"0.5",
FCVAR_REPLICATED,
"Number of seconds to delay showing information in the status bar",
true, 0,
true, 1 );
ConVar mp_playerid_hold(
"mp_playerid_hold",
"0.25",
FCVAR_REPLICATED,
"Number of seconds to keep showing old information in the status bar",
true, 0,
true, 1 );
ConVar mp_round_restart_delay(
"mp_round_restart_delay",
"5.0",
FCVAR_REPLICATED,
"Number of seconds to delay before restarting a round after a win",
true, 0.0f,
true, 10.0f );
ConVar sv_allowminmodels(
"sv_allowminmodels",
"1",
FCVAR_REPLICATED | FCVAR_NOTIFY,
"Allow or disallow the use of cl_minmodels on this server." );
#ifdef CLIENT_DLL
ConVar cl_autowepswitch(
"cl_autowepswitch",
"1",
FCVAR_ARCHIVE | FCVAR_USERINFO,
"Automatically switch to picked up weapons (if more powerful)" );
ConVar cl_autohelp(
"cl_autohelp",
"1",
FCVAR_ARCHIVE | FCVAR_USERINFO,
"Auto-help" );
#else
// longest the intermission can last, in seconds
#define MAX_INTERMISSION_TIME 120
// Falling damage stuff.
#define CS_PLAYER_FATAL_FALL_SPEED 1100 // approx 60 feet
#define CS_PLAYER_MAX_SAFE_FALL_SPEED 580 // approx 20 feet
#define CS_DAMAGE_FOR_FALL_SPEED ((float)100 / ( CS_PLAYER_FATAL_FALL_SPEED - CS_PLAYER_MAX_SAFE_FALL_SPEED )) // damage per unit per second.
// These entities are preserved each round restart. The rest are removed and recreated.
static const char *s_PreserveEnts[] =
{
"ai_network",
"ai_hint",
"cs_gamerules",
"cs_team_manager",
"cs_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",
"func_hostage_rescue",
"func_bomb_target",
"infodecal",
"info_projecteddecal",
"info_node",
"info_target",
"info_node_hint",
"info_player_counterterrorist",
"info_player_terrorist",
"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
};
// --------------------------------------------------------------------------------------------------- //
// Voice helper
// --------------------------------------------------------------------------------------------------- //
class CVoiceGameMgrHelper : public IVoiceGameMgrHelper
{
public:
virtual bool CanPlayerHearPlayer( CBasePlayer *pListener, CBasePlayer *pTalker, bool &bProximity )
{
// Dead players can only be heard by other dead team mates
if ( pTalker->IsAlive() == false )
{
if ( pListener->IsAlive() == false )
return ( pListener->InSameTeam( pTalker ) );
return false;
}
return ( pListener->InSameTeam( pTalker ) );
}
};
CVoiceGameMgrHelper g_VoiceGameMgrHelper;
IVoiceGameMgrHelper *g_pVoiceGameMgrHelper = &g_VoiceGameMgrHelper;
// --------------------------------------------------------------------------------------------------- //
// Globals.
// --------------------------------------------------------------------------------------------------- //
// NOTE: the indices here must match TEAM_TERRORIST, TEAM_CT, TEAM_SPECTATOR, etc.
const char *sTeamNames[] =
{
"Unassigned",
"Spectator",
"TERRORIST",
"CT"
};
extern ConVar mp_maxrounds;
ConVar mp_startmoney(
"mp_startmoney",
"800",
FCVAR_REPLICATED | FCVAR_NOTIFY,
"amount of money each player gets when they reset",
true, 800,
true, 16000 );
ConVar mp_roundtime(
"mp_roundtime",
"2.5",
FCVAR_REPLICATED | FCVAR_NOTIFY,
"How many minutes each round takes.",
true, 1, // min value
true, 9 // max value
);
ConVar mp_freezetime(
"mp_freezetime",
"6",
FCVAR_REPLICATED | FCVAR_NOTIFY,
"how many seconds to keep players frozen when the round starts",
true, 0, // min value
true, 60 // max value
);
ConVar mp_c4timer(
"mp_c4timer",
"45",
FCVAR_REPLICATED | FCVAR_NOTIFY,
"how long from when the C4 is armed until it blows",
true, 10, // min value
true, 90 // max value
);
ConVar mp_limitteams(
"mp_limitteams",
"2",
FCVAR_REPLICATED | FCVAR_NOTIFY,
"Max # of players 1 team can have over another (0 disables check)",
true, 0, // min value
true, 30 // max value
);
ConVar mp_tkpunish(
"mp_tkpunish",
"0",
FCVAR_REPLICATED,
"Will a TK'er be punished in the next round? {0=no, 1=yes}" );
ConVar mp_autokick(
"mp_autokick",
"1",
FCVAR_REPLICATED,
"Kick idle/team-killing players" );
ConVar mp_spawnprotectiontime(
"mp_spawnprotectiontime",
"5",
FCVAR_REPLICATED,
"Kick players who team-kill within this many seconds of a round restart." );
ConVar mp_humanteam(
"mp_humanteam",
"any",
FCVAR_REPLICATED,
"Restricts human players to a single team {any, CT, T}" );
ConVar mp_ignore_round_win_conditions(
"mp_ignore_round_win_conditions",
"0",
FCVAR_REPLICATED,
"Ignore conditions which would end the current round");
ConCommand EndRound( "endround", &CCSGameRules::EndRound, "End the current round.", FCVAR_CHEAT );
// --------------------------------------------------------------------------------------------------- //
// Global helper functions.
// --------------------------------------------------------------------------------------------------- //
void InitBodyQue(void)
{
// FIXME: Make this work
}
Vector DropToGround(
CBaseEntity *pMainEnt,
const Vector &vPos,
const Vector &vMins,
const Vector &vMaxs )
{
trace_t trace;
UTIL_TraceHull( vPos, vPos + Vector( 0, 0, -500 ), vMins, vMaxs, MASK_SOLID, pMainEnt, COLLISION_GROUP_NONE, &trace );
return trace.endpos;
}
//-----------------------------------------------------------------------------
// Purpose: This function can be used to find a valid placement location for an entity.
// Given an origin to start looking from and a minimum radius to place the entity at,
// it will sweep out a circle around vOrigin and try to find a valid spot (on the ground)
// where mins and maxs will fit.
// Input : *pMainEnt - Entity to place
// &vOrigin - Point to search around
// fRadius - Radius to search within
// nTries - Number of tries to attempt
// &mins - mins of the Entity
// &maxs - maxs of the Entity
// &outPos - Return point
// Output : Returns true and fills in outPos if it found a spot.
//-----------------------------------------------------------------------------
bool EntityPlacementTest( CBaseEntity *pMainEnt, const Vector &vOrigin, Vector &outPos, bool bDropToGround )
{
// This function moves the box out in each dimension in each step trying to find empty space like this:
//
// X
// X X
// Step 1: X Step 2: XXX Step 3: XXXXX
// X X
// X
//
Vector mins, maxs;
pMainEnt->CollisionProp()->WorldSpaceAABB( &mins, &maxs );
mins -= pMainEnt->GetAbsOrigin();
maxs -= pMainEnt->GetAbsOrigin();
// Put some padding on their bbox.
float flPadSize = 5;
Vector vTestMins = mins - Vector( flPadSize, flPadSize, flPadSize );
Vector vTestMaxs = maxs + Vector( flPadSize, flPadSize, flPadSize );
// First test the starting origin.
if ( UTIL_IsSpaceEmpty( pMainEnt, vOrigin + vTestMins, vOrigin + vTestMaxs ) )
{
if ( bDropToGround )
{
outPos = DropToGround( pMainEnt, vOrigin, vTestMins, vTestMaxs );
}
else
{
outPos = vOrigin;
}
return true;
}
Vector vDims = vTestMaxs - vTestMins;
// Keep branching out until we get too far.
int iCurIteration = 0;
int nMaxIterations = 15;
int offset = 0;
do
{
for ( int iDim=0; iDim < 3; iDim++ )
{
float flCurOffset = offset * vDims[iDim];
for ( int iSign=0; iSign < 2; iSign++ )
{
Vector vBase = vOrigin;
vBase[iDim] += (iSign*2-1) * flCurOffset;
if ( UTIL_IsSpaceEmpty( pMainEnt, vBase + vTestMins, vBase + vTestMaxs ) )
{
// Ensure that there is a clear line of sight from the spawnpoint entity to the actual spawn point.
// (Useful for keeping things from spawning behind walls near a spawn point)
trace_t tr;
UTIL_TraceLine( vOrigin, vBase, MASK_SOLID, pMainEnt, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction != 1.0 )
{
continue;
}
if ( bDropToGround )
outPos = DropToGround( pMainEnt, vBase, vTestMins, vTestMaxs );
else
outPos = vBase;
return true;
}
}
}
++offset;
} while ( iCurIteration++ < nMaxIterations );
// Warning( "EntityPlacementTest for ent %d:%s failed!\n", pMainEnt->entindex(), pMainEnt->GetClassname() );
return false;
}
int UTIL_HumansInGame( bool ignoreSpectators )
{
int iCount = 0;
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CCSPlayer *entity = CCSPlayer::Instance( i );
if ( entity && !FNullEnt( entity->edict() ) )
{
if ( FStrEq( entity->GetPlayerName(), "" ) )
continue;
if ( FBitSet( entity->GetFlags(), FL_FAKECLIENT ) )
continue;
if ( ignoreSpectators && entity->GetTeamNumber() != TEAM_TERRORIST && entity->GetTeamNumber() != TEAM_CT )
continue;
if ( ignoreSpectators && entity->State_Get() == STATE_PICKINGCLASS )
continue;
iCount++;
}
}
return iCount;
}
// --------------------------------------------------------------------------------------------------- //
// CCSGameRules implementation.
// --------------------------------------------------------------------------------------------------- //
CCSGameRules::CCSGameRules()
{
m_iRoundTime = 0;
m_iRoundWinStatus = WINNER_NONE;
m_iFreezeTime = 0;
m_fRoundStartTime = 0;
m_bAllowWeaponSwitch = true;
m_bFreezePeriod = true;
m_iNumTerrorist = m_iNumCT = 0; // number of players per team
m_flRestartRoundTime = 0.1f; // restart first round as soon as possible
m_iNumSpawnableTerrorist = m_iNumSpawnableCT = 0;
m_bFirstConnected = false;
m_bCompleteReset = false;
m_iAccountTerrorist = m_iAccountCT = 0;
m_iNumCTWins = 0;
m_iNumTerroristWins = 0;
m_iNumConsecutiveCTLoses = 0;
m_iNumConsecutiveTerroristLoses = 0;
m_bTargetBombed = false;
m_bBombDefused = false;
m_iTotalRoundsPlayed = -1;
m_iUnBalancedRounds = 0;
m_flGameStartTime = 0;
m_iHostagesRemaining = 0;
m_bLevelInitialized = false;
m_bLogoMap = false;
m_tmNextPeriodicThink = 0;
m_bMapHasBombTarget = false;
m_bMapHasRescueZone = false;
m_iSpawnPointCount_Terrorist = 0;
m_iSpawnPointCount_CT = 0;
m_bTCantBuy = false;
m_bCTCantBuy = false;
m_bMapHasBuyZone = false;
m_iLoserBonus = 0;
m_iHostagesRescued = 0;
m_iHostagesTouched = 0;
m_flNextHostageAnnouncement = 0.0f;
//=============================================================================
// HPE_BEGIN
// [dwenger] Reset rescue-related achievement values
//=============================================================================
// [tj] reset flawless and lossless round related flags
m_bNoTerroristsKilled = true;
m_bNoCTsKilled = true;
m_bNoTerroristsDamaged = true;
m_bNoCTsDamaged = true;
m_pFirstKill = NULL;
m_firstKillTime = 0;
// [menglish] Reset fun fact values
m_pFirstBlood = NULL;
m_firstBloodTime = 0;
m_bCanDonateWeapons = true;
// [dwenger] Reset rescue-related achievement values
m_pLastRescuer = NULL;
m_iNumRescuers = 0;
m_hostageWasInjured = false;
m_hostageWasKilled = false;
m_pFunFactManager = new CCSFunFactMgr();
m_pFunFactManager->Init();
//=============================================================================
// HPE_END
//=============================================================================
m_iHaveEscaped = 0;
m_bMapHasEscapeZone = false;
m_iNumEscapers = 0;
m_iNumEscapeRounds = 0;
m_iMapHasVIPSafetyZone = 0;
m_pVIP = NULL;
m_iConsecutiveVIP = 0;
m_bMapHasBombZone = false;
m_bBombDropped = false;
m_bBombPlanted = false;
m_pLastBombGuy = NULL;
m_bAllowWeaponSwitch = true;
m_flNextHostageAnnouncement = gpGlobals->curtime; // asap.
ReadMultiplayCvars();
m_pPrices = NULL;
m_bBlackMarket = false;
m_bDontUploadStats = false;
// Create the team managers
for ( int i = 0; i < ARRAYSIZE( sTeamNames ); i++ )
{
CTeam *pTeam = static_cast<CTeam*>(CreateEntityByName( "cs_team_manager" ));
pTeam->Init( sTeamNames[i], i );
g_Teams.AddToTail( pTeam );
}
if ( filesystem->FileExists( UTIL_VarArgs( "maps/cfg/%s.cfg", STRING(gpGlobals->mapname) ) ) )
{
// Execute a map specific cfg file - as in Day of Defeat
// Map names cannot contain quotes or control characters so this is safe but silly that we have to do it.
engine->ServerCommand( UTIL_VarArgs( "exec \"%s.cfg\" */maps\n", STRING(gpGlobals->mapname) ) );
engine->ServerExecute();
}
#ifndef CLIENT_DLL
// stats
if ( g_flGameStatsUpdateTime == 0.0f )
{
memset( g_iWeaponPurchases, 0, sizeof( g_iWeaponPurchases) );
memset( g_iTerroristVictories, 0, sizeof( g_iTerroristVictories) );
memset( g_iCounterTVictories, 0, sizeof( g_iTerroristVictories) );
g_flGameStatsUpdateTime = CS_GAME_STATS_UPDATE; //Next update is between 22 and 24 hours.
}
#endif
}
void CCSGameRules::AddPricesToTable( weeklyprice_t prices )
{
int iIndex = m_StringTableBlackMarket->FindStringIndex( "blackmarket_prices" );
if ( iIndex == INVALID_STRING_INDEX )
{
m_StringTableBlackMarket->AddString( CBaseEntity::IsServer(), "blackmarket_prices", sizeof( weeklyprice_t), &prices );
}
else
{
m_StringTableBlackMarket->SetStringUserData( iIndex, sizeof( weeklyprice_t), &prices );
}
SetBlackMarketPrices( false );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CCSGameRules::~CCSGameRules()
{
// Note, don't delete each team since they are in the gEntList and will
// automatically be deleted from there, instead.
g_Teams.Purge();
if( m_pFunFactManager )
{
delete m_pFunFactManager;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CCSGameRules::UpdateClientData( CBasePlayer *player )
{
}
//-----------------------------------------------------------------------------
// Purpose: TF2 Specific Client Commands
// Input :
// Output :
//-----------------------------------------------------------------------------
bool CCSGameRules::ClientCommand( CBaseEntity *pEdict, const CCommand &args )
{
CCSPlayer *pPlayer = ToCSPlayer( pEdict );
if ( FStrEq( args[0], "changeteam" ) )
{
return true;
}
else if ( FStrEq( args[0], "nextmap" ) )
{
if ( pPlayer->m_iNextTimeCheck < gpGlobals->curtime )
{
char szNextMap[32];
if ( nextlevel.GetString() && *nextlevel.GetString() )
{
Q_strncpy( szNextMap, nextlevel.GetString(), sizeof( szNextMap ) );
}
else
{
GetNextLevelName( szNextMap, sizeof( szNextMap ) );
}
ClientPrint( pPlayer, HUD_PRINTTALK, "#game_nextmap", szNextMap);
pPlayer->m_iNextTimeCheck = gpGlobals->curtime + 1;
}
return true;
}
else if( pPlayer->ClientCommand( args ) )
{
return true;
}
else if( BaseClass::ClientCommand( pEdict, args ) )
{
return true;
}
else if ( TheBots->ServerCommand( args.GetCommandString() ) )
{
return true;
}
else
{
return TheBots->ClientCommand( pPlayer, args );
}
}
//-----------------------------------------------------------------------------
// Purpose: Player has just spawned. Equip them.
//-----------------------------------------------------------------------------
void CCSGameRules::ClientCommandKeyValues( edict_t *pEntity, KeyValues *pKeyValues )
{
CCSPlayer *pPlayer = dynamic_cast< CCSPlayer * >( CBaseEntity::Instance( pEntity ) );
if ( pPlayer )
{
char const *pszCommand = pKeyValues->GetName();
if ( pszCommand && pszCommand[0] )
{
if ( FStrEq( pszCommand, "ClanTagChanged" ) )
{
pPlayer->SetClanTag( pKeyValues->GetString( "tag", "" ) );
const char *teamName = "UNKNOWN";
if ( pPlayer->GetTeam() )
{
teamName = pPlayer->GetTeam()->GetName();
}
UTIL_LogPrintf("\"%s<%i><%s><%s>\" triggered \"clantag\" (value \"%s\")\n",
pPlayer->GetPlayerName(),
pPlayer->GetUserID(),
pPlayer->GetNetworkIDString(),
teamName,
pKeyValues->GetString( "tag", "unknown" ) );
}
}
}
BaseClass::ClientCommandKeyValues( pEntity, pKeyValues );
}
//-----------------------------------------------------------------------------
// Purpose: Player has just spawned. Equip them.
//-----------------------------------------------------------------------------
void CCSGameRules::PlayerSpawn( CBasePlayer *pBasePlayer )
{
CCSPlayer *pPlayer = ToCSPlayer( pBasePlayer );
if ( !pPlayer )
Error( "PlayerSpawn" );
if ( pPlayer->State_Get() != STATE_ACTIVE )
return;
pPlayer->EquipSuit();
bool addDefault = true;
CBaseEntity *pWeaponEntity = NULL;
while ( ( pWeaponEntity = gEntList.FindEntityByClassname( pWeaponEntity, "game_player_equip" )) != NULL )
{
if ( addDefault )
{
// remove all our weapons and armor before touching the first game_player_equip
pPlayer->RemoveAllItems( true );
}
pWeaponEntity->Touch( pPlayer );
addDefault = false;
}
if ( addDefault || pPlayer->m_bIsVIP )
pPlayer->GiveDefaultItems();
}
void CCSGameRules::BroadcastSound( const char *sound, int team )
{
CBroadcastRecipientFilter filter;
filter.MakeReliable();
if( team != -1 )
{
filter.RemoveAllRecipients();
filter.AddRecipientsByTeam( GetGlobalTeam(team) );
}
UserMessageBegin ( filter, "SendAudio" );
WRITE_STRING( sound );
MessageEnd();
}
//-----------------------------------------------------------------------------
// Purpose: Player has just spawned. Equip them.
//-----------------------------------------------------------------------------
// return a multiplier that should adjust the damage done by a blast at position vecSrc to something at the position
// vecEnd. This will take into account the density of an entity that blocks the line of sight from one position to
// the other.
//
// this algorithm was taken from the HL2 version of RadiusDamage.
float CCSGameRules::GetExplosionDamageAdjustment(Vector & vecSrc, Vector & vecEnd, CBaseEntity *pEntityToIgnore)
{
float retval = 0.0;
trace_t tr;
UTIL_TraceLine(vecSrc, vecEnd, MASK_SHOT, pEntityToIgnore, COLLISION_GROUP_NONE, &tr);
if (tr.fraction == 1.0)
{
retval = 1.0;
}
else if (!(tr.DidHitWorld()) && (tr.m_pEnt != NULL) && (tr.m_pEnt != pEntityToIgnore) && (tr.m_pEnt->GetOwnerEntity() != pEntityToIgnore))
{
// if we didn't hit world geometry perhaps there's still damage to be done here.
CBaseEntity *blockingEntity = tr.m_pEnt;
// check to see if this part of the player is visible if entities are ignored.
UTIL_TraceLine(vecSrc, vecEnd, CONTENTS_SOLID, NULL, COLLISION_GROUP_NONE, &tr);
if (tr.fraction == 1.0)
{
if ((blockingEntity != NULL) && (blockingEntity->VPhysicsGetObject() != NULL))
{
int nMaterialIndex = blockingEntity->VPhysicsGetObject()->GetMaterialIndex();
float flDensity;
float flThickness;
float flFriction;
float flElasticity;
physprops->GetPhysicsProperties( nMaterialIndex, &flDensity,
&flThickness, &flFriction, &flElasticity );
const float DENSITY_ABSORB_ALL_DAMAGE = 3000.0;
float scale = flDensity / DENSITY_ABSORB_ALL_DAMAGE;
if ((scale >= 0.0) && (scale < 1.0))
{
retval = 1.0 - scale;
}
else if (scale < 0.0)
{
// should never happen, but just in case.
retval = 1.0;
}
}
else
{
retval = 0.75; // we're blocked by something that isn't an entity with a physics module or world geometry, just cut damage in half for now.
}
}
}
return retval;
}
// returns the percentage of the player that is visible from the given point in the world.
// return value is between 0 and 1.
float CCSGameRules::GetAmountOfEntityVisible(Vector & vecSrc, CBaseEntity *entity)
{
float retval = 0.0;
const float damagePercentageChest = 0.40;
const float damagePercentageHead = 0.20;
const float damagePercentageFeet = 0.20;
const float damagePercentageRightSide = 0.10;
const float damagePercentageLeftSide = 0.10;
if (!(entity->IsPlayer()))
{
// the entity is not a player, so the damage is all or nothing.
Vector vecTarget;
vecTarget = entity->BodyTarget(vecSrc, false);
return GetExplosionDamageAdjustment(vecSrc, vecTarget, entity);
}
CCSPlayer *player = (CCSPlayer *)entity;
// check what parts of the player we can see from this point and modify the return value accordingly.
float chestHeightFromFeet;
float armDistanceFromChest = HalfHumanWidth;
// calculate positions of various points on the target player's body
Vector vecFeet = player->GetAbsOrigin();
Vector vecChest = player->BodyTarget(vecSrc, false);
chestHeightFromFeet = vecChest.z - vecFeet.z; // compute the distance from the chest to the feet. (this accounts for ducking and the like)
Vector vecHead = player->GetAbsOrigin();
vecHead.z += HumanHeight;
Vector vecRightFacing;
AngleVectors(player->GetAbsAngles(), NULL, &vecRightFacing, NULL);
vecRightFacing.NormalizeInPlace();
vecRightFacing = vecRightFacing * armDistanceFromChest;
Vector vecLeftSide = player->GetAbsOrigin();
vecLeftSide.x -= vecRightFacing.x;
vecLeftSide.y -= vecRightFacing.y;
vecLeftSide.z += chestHeightFromFeet;
Vector vecRightSide = player->GetAbsOrigin();
vecRightSide.x += vecRightFacing.x;
vecRightSide.y += vecRightFacing.y;
vecRightSide.z += chestHeightFromFeet;
// check chest
float damageAdjustment = GetExplosionDamageAdjustment(vecSrc, vecChest, entity);
retval += (damagePercentageChest * damageAdjustment);
// check top of head
damageAdjustment = GetExplosionDamageAdjustment(vecSrc, vecHead, entity);
retval += (damagePercentageHead * damageAdjustment);
// check feet
damageAdjustment = GetExplosionDamageAdjustment(vecSrc, vecFeet, entity);
retval += (damagePercentageFeet * damageAdjustment);
// check left "edge"
damageAdjustment = GetExplosionDamageAdjustment(vecSrc, vecLeftSide, entity);
retval += (damagePercentageLeftSide * damageAdjustment);
// check right "edge"
damageAdjustment = GetExplosionDamageAdjustment(vecSrc, vecRightSide, entity);
retval += (damagePercentageRightSide * damageAdjustment);
return retval;
}
void CCSGameRules::RadiusDamage( const CTakeDamageInfo &info, const Vector &vecSrcIn, float flRadius, int iClassIgnore, CBaseEntity * pEntityIgnore )
{
RadiusDamage( info, vecSrcIn, flRadius, iClassIgnore, false );
}
// Add the ability to ignore the world trace
void CCSGameRules::RadiusDamage( const CTakeDamageInfo &info, const Vector &vecSrcIn, float flRadius, int iClassIgnore, bool bIgnoreWorld )
{
CBaseEntity *pEntity = NULL;
trace_t tr;
float falloff, damagePercentage;
Vector vecSpot;
Vector vecToTarget;
Vector vecEndPos;
//=============================================================================
// HPE_BEGIN:
//=============================================================================
// [tj] The number of enemy players this explosion killed
int numberOfEnemyPlayersKilledByThisExplosion = 0;
// [tj] who we award the achievement to if enough players are killed
CCSPlayer* pCSExplosionAttacker = ToCSPlayer(info.GetAttacker());
// [tj] used to determine which achievement to award for sufficient kills
CBaseEntity* pInflictor = info.GetInflictor();
bool isGrenade = pInflictor && V_strcmp(pInflictor->GetClassname(), "hegrenade_projectile") == 0;
bool isBomb = pInflictor && V_strcmp(pInflictor->GetClassname(), "planted_c4") == 0;
//=============================================================================
// HPE_END
//=============================================================================
vecEndPos.Init();
Vector vecSrc = vecSrcIn;
damagePercentage = 1.0;
if ( flRadius )
falloff = info.GetDamage() / flRadius;
else
falloff = 1.0;
int bInWater = (UTIL_PointContents ( vecSrc ) & MASK_WATER) ? true : false;
vecSrc.z += 1;// in case grenade is lying on the ground
// iterate on all entities in the vicinity.
for ( CEntitySphereQuery sphere( vecSrc, flRadius ); ( pEntity = sphere.GetCurrentEntity() ) != NULL; sphere.NextEntity() )
{
//=============================================================================
// HPE_BEGIN:
// [tj] We have to save whether or not the player is killed so we don't give credit
// for pre-dead players.
//=============================================================================
bool wasAliveBeforeExplosion = false;
CCSPlayer* pCSExplosionVictim = ToCSPlayer(pEntity);
if (pCSExplosionVictim)
{
wasAliveBeforeExplosion = pCSExplosionVictim->IsAlive();
}
//=============================================================================
// HPE_END
//=============================================================================
if ( pEntity->m_takedamage != DAMAGE_NO )
{
// UNDONE: this should check a damage mask, not an ignore
if ( iClassIgnore != CLASS_NONE && pEntity->Classify() == iClassIgnore )
{// houndeyes don't hurt other houndeyes with their attack
continue;
}
// blasts don't travel into or out of water
if ( !bIgnoreWorld )
{
if (bInWater && pEntity->GetWaterLevel() == 0)
continue;
if (!bInWater && pEntity->GetWaterLevel() == 3)
continue;
}
// radius damage can only be blocked by the world
vecSpot = pEntity->BodyTarget( vecSrc );
bool bHit = false;
if( bIgnoreWorld )
{
vecEndPos = vecSpot;
bHit = true;
}
else
{
// get the percentage of the target entity that is visible from the
// explosion position.
damagePercentage = GetAmountOfEntityVisible(vecSrc, pEntity);
if (damagePercentage > 0.0)
{
vecEndPos = vecSpot;
bHit = true;
}
}
if ( bHit )
{
// the explosion can 'see' this entity, so hurt them!
//vecToTarget = ( vecSrc - vecEndPos );
vecToTarget = ( vecEndPos - vecSrc );
// use a Gaussian function to describe the damage falloff over distance, with flRadius equal to 3 * sigma
// this results in the following values:
//
// Range Fraction Damage
// 0.0 100%
// 0.1 96%
// 0.2 84%
// 0.3 67%
// 0.4 49%
// 0.5 32%
// 0.6 20%
// 0.7 11%
// 0.8 6%
// 0.9 3%
// 1.0 1%
float fDist = vecToTarget.Length();
float fSigma = flRadius / 3.0f; // flRadius specifies 3rd standard deviation (0.0111 damage at this range)
float fGaussianFalloff = exp(-fDist * fDist / (2.0f * fSigma * fSigma));
float flAdjustedDamage = info.GetDamage() * fGaussianFalloff * damagePercentage;
if ( flAdjustedDamage > 0 )
{
CTakeDamageInfo adjustedInfo = info;
adjustedInfo.SetDamage( flAdjustedDamage );
Vector dir = vecToTarget;
VectorNormalize( dir );
// If we don't have a damage force, manufacture one
if ( adjustedInfo.GetDamagePosition() == vec3_origin || adjustedInfo.GetDamageForce() == vec3_origin )
{
CalculateExplosiveDamageForce( &adjustedInfo, dir, vecSrc, 1.5 /* explosion scale! */ );
}
else
{
// Assume the force passed in is the maximum force. Decay it based on falloff.
float flForce = adjustedInfo.GetDamageForce().Length() * falloff;
adjustedInfo.SetDamageForce( dir * flForce );
adjustedInfo.SetDamagePosition( vecSrc );
}
Vector vecTarget;
vecTarget = pEntity->BodyTarget(vecSrc, false);
UTIL_TraceLine(vecSrc, vecTarget, MASK_SHOT, NULL, COLLISION_GROUP_NONE, &tr);
// blasts always hit chest
tr.hitgroup = HITGROUP_GENERIC;
if (tr.fraction != 1.0)
{
// this has to be done to make breakable glass work.
ClearMultiDamage( );
pEntity->DispatchTraceAttack( adjustedInfo, dir, &tr );
ApplyMultiDamage();
}
else
{
pEntity->TakeDamage( adjustedInfo );
}
// Now hit all triggers along the way that respond to damage...
pEntity->TraceAttackToTriggers( adjustedInfo, vecSrc, vecEndPos, dir );
//=============================================================================
// HPE_BEGIN:
// [sbodenbender] Increment grenade damage stat
//=============================================================================
if (pCSExplosionVictim && pCSExplosionAttacker && isGrenade)
{
CCS_GameStats.IncrementStat(pCSExplosionAttacker, CSSTAT_GRENADE_DAMAGE, static_cast<int>(adjustedInfo.GetDamage()));
}
//=============================================================================
// HPE_END
//=============================================================================
}
}
}
//=============================================================================
// HPE_BEGIN:
// [tj] Count up victims of area of effect damage for achievement purposes
//=============================================================================
if (pCSExplosionVictim)
{
//If the bomb is exploding, set the attacker to the planter (we can't put this in the CTakeDamageInfo, since
//players aren't supposed to get credit for bomb kills)
if (isBomb)
{
CPlantedC4* bomb = static_cast<CPlantedC4*> (pInflictor);
if (bomb)
{
pCSExplosionAttacker = bomb->GetPlanter();
}
}
//Count check to make sure we killed an enemy player
if( pCSExplosionAttacker &&
!pCSExplosionVictim->IsAlive() &&
wasAliveBeforeExplosion &&
pCSExplosionVictim->GetTeamNumber() != pCSExplosionAttacker->GetTeamNumber())
{
numberOfEnemyPlayersKilledByThisExplosion++;
}
}
//=============================================================================
// HPE_END
//=============================================================================
}
//=============================================================================
// HPE_BEGIN:
// [tj] //Depending on which type of explosion it was, award the appropriate achievement.
//=============================================================================
if (pCSExplosionAttacker && isGrenade && numberOfEnemyPlayersKilledByThisExplosion >= AchievementConsts::GrenadeMultiKill_MinKills)
{
pCSExplosionAttacker->AwardAchievement(CSGrenadeMultikill);
pCSExplosionAttacker->CheckMaxGrenadeKills(numberOfEnemyPlayersKilledByThisExplosion);
}
if (pCSExplosionAttacker && isBomb && numberOfEnemyPlayersKilledByThisExplosion >= AchievementConsts::BombMultiKill_MinKills)
{
pCSExplosionAttacker->AwardAchievement(CSBombMultikill);
}
//=============================================================================
// HPE_END
//=============================================================================
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pVictim -
// *pKiller -
// *pInflictor -
//-----------------------------------------------------------------------------
void CCSGameRules::DeathNotice( CBasePlayer *pVictim, const CTakeDamageInfo &info )
{
// 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 );
CCSPlayer *pCSVictim = (CCSPlayer*)(pVictim);
bool bHeadshot = false;
if ( pScorer ) // Is the killer a client?
{
killer_ID = pScorer->GetUserID();
if( info.GetDamageType() & DMG_HEADSHOT )
{
//to enable drawing the headshot icon as well as the weapon icon,
bHeadshot = true;
}
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(); //GetDeathNoticeName();
}
}
else
{
killer_weapon_name = STRING( pInflictor->m_iClassname ); // it's just that easy
}
}
}
else
{
killer_weapon_name = STRING( pInflictor->m_iClassname );
}
// 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_", 8 ) == 0 )
{
killer_weapon_name += 8;
}
else if ( strncmp( killer_weapon_name, "func_", 5 ) == 0 )
{
killer_weapon_name += 5;
}
else if( strncmp( killer_weapon_name, "hegrenade", 9 ) == 0 ) //"hegrenade_projectile"
{
killer_weapon_name = "hegrenade";
}
else if( strncmp( killer_weapon_name, "flashbang", 9 ) == 0 ) //"flashbang_projectile"
{
killer_weapon_name = "flashbang";
}
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("headshot", bHeadshot ? 1 : 0 );
event->SetInt("priority", bHeadshot ? 8 : 7 ); // HLTV event priority, not transmitted
if ( pCSVictim->GetDeathFlags() & CS_DEATH_DOMINATION )
{
event->SetInt( "dominated", 1 );
}
else if ( pCSVictim->GetDeathFlags() & CS_DEATH_REVENGE )
{
event->SetInt( "revenge", 1 );
}
gameeventmanager->FireEvent( event );
}
}
//=========================================================
//=========================================================
void CCSGameRules::PlayerKilled( CBasePlayer *pVictim, const CTakeDamageInfo &info )
{
CBaseEntity *pInflictor = info.GetInflictor();
CBaseEntity *pKiller = info.GetAttacker();
CBasePlayer *pScorer = GetDeathScorer( pKiller, pInflictor );
CCSPlayer *pCSVictim = (CCSPlayer *)pVictim;
CCSPlayer *pCSScorer = (CCSPlayer *)pScorer;
CCS_GameStats.PlayerKilled( pVictim, info );
//=============================================================================
// HPE_BEGIN:
// [tj] Flag the round as non-lossless for the appropriate team.
// [menglish] Set the death flags depending on a nemesis system
//=============================================================================
if (pVictim->GetTeamNumber() == TEAM_TERRORIST)
{
m_bNoTerroristsKilled = false;
m_bNoTerroristsDamaged = false;
}
if (pVictim->GetTeamNumber() == TEAM_CT)
{
m_bNoCTsKilled = false;
m_bNoCTsDamaged = false;
}
m_bCanDonateWeapons = false;
if ( m_pFirstKill == NULL && pCSScorer != pVictim )
{
m_pFirstKill = pCSScorer;
m_firstKillTime = gpGlobals->curtime - m_fRoundStartTime;
}
// determine if this kill affected a nemesis relationship
int iDeathFlags = 0;
if ( pScorer )
{
CCS_GameStats.CalculateOverkill( pCSScorer, pCSVictim);
CCS_GameStats.CalcDominationAndRevenge( pCSScorer, pCSVictim, &iDeathFlags );
}
pCSVictim->SetDeathFlags( iDeathFlags );
//=============================================================================
// HPE_END
//=============================================================================
// If we're killed by the C4, we do a subset of BaseClass::PlayerKilled()
// Specifically, we shouldn't lose any points or show death notices, to match goldsrc
if ( Q_strcmp(pKiller->GetClassname(), "planted_c4" ) == 0 )
{
// dvsents2: uncomment when removing all FireTargets
// variant_t value;
// g_EventQueue.AddEvent( "game_playerdie", "Use", value, 0, pVictim, pVictim );
FireTargets( "game_playerdie", pVictim, pVictim, USE_TOGGLE, 0 );
}
else
{
BaseClass::PlayerKilled( pVictim, info );
}
// check for team-killing, and give monetary rewards/penalties
// Find the killer & the scorer
if ( !pScorer )
return;
if ( IPointsForKill( pScorer, pVictim ) < 0 )
{
// team-killer!
pCSScorer->AddAccount( -3300 );
++pCSScorer->m_iTeamKills;
pCSScorer->m_bJustKilledTeammate = true;
ClientPrint( pCSScorer, HUD_PRINTCENTER, "#Killed_Teammate" );
if ( mp_autokick.GetBool() )
{
char strTeamKills[64];
Q_snprintf( strTeamKills, sizeof( strTeamKills ), "%d", pCSScorer->m_iTeamKills );
ClientPrint( pCSScorer, HUD_PRINTCONSOLE, "#Game_teammate_kills", strTeamKills ); // this includes a " of 3" in it
if ( pCSScorer->m_iTeamKills >= 3 )
{
ClientPrint( pCSScorer, HUD_PRINTCONSOLE, "#Banned_For_Killing_Teammates" );
engine->ServerCommand( UTIL_VarArgs( "kickid %d\n", pCSScorer->GetUserID() ) );
}
else if ( mp_spawnprotectiontime.GetInt() > 0 && GetRoundElapsedTime() < mp_spawnprotectiontime.GetInt() )
{
ClientPrint( pCSScorer, HUD_PRINTCONSOLE, "#Banned_For_Killing_Teammates" );
engine->ServerCommand( UTIL_VarArgs( "kickid %d\n", pCSScorer->GetUserID() ) );
}
}
if ( !(pCSScorer->m_iDisplayHistoryBits & DHF_FRIEND_KILLED) )
{
pCSScorer->m_iDisplayHistoryBits |= DHF_FRIEND_KILLED;
pCSScorer->HintMessage( "#Hint_careful_around_teammates", false );
}
}
else
{
//=============================================================================
// HPE_BEGIN:
// [tj] Added a check to make sure we don't get money for suicides.
//=============================================================================
if (pCSScorer != pCSVictim)
{
//=============================================================================
// HPE_END
//=============================================================================
if ( pCSVictim->IsVIP() )
{
pCSScorer->HintMessage( "#Hint_reward_for_killing_vip", true );
pCSScorer->AddAccount( 2500 );
}
else
{
pCSScorer->AddAccount( 300 );
}
}
if ( !(pCSScorer->m_iDisplayHistoryBits & DHF_ENEMY_KILLED) )
{
pCSScorer->m_iDisplayHistoryBits |= DHF_ENEMY_KILLED;
pCSScorer->HintMessage( "#Hint_win_round_by_killing_enemy", false );
}
}
}
void CCSGameRules::InitDefaultAIRelationships()
{
// Allocate memory for default relationships
CBaseCombatCharacter::AllocateDefaultRelationships();
// --------------------------------------------------------------
// First initialize table so we can report missing relationships
// --------------------------------------------------------------
int i, j;
for (i=0;i<NUM_AI_CLASSES;i++)
{
for (j=0;j<NUM_AI_CLASSES;j++)
{
// By default all relationships are neutral of priority zero
CBaseCombatCharacter::SetDefaultRelationship( (Class_T)i, (Class_T)j, D_NU, 0 );
}
}
}
//------------------------------------------------------------------------------
// Purpose : Return classify text for classify type
//------------------------------------------------------------------------------
const char *CCSGameRules::AIClassText(int classType)
{
switch (classType)
{
case CLASS_NONE: return "CLASS_NONE";
case CLASS_PLAYER: return "CLASS_PLAYER";
default: return "MISSING CLASS in ClassifyText()";
}
}
//-----------------------------------------------------------------------------
// Purpose: When gaining new technologies in TF, prevent auto switching if we
// receive a weapon during the switch
// Input : *pPlayer -
// *pWeapon -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CCSGameRules::FShouldSwitchWeapon( CBasePlayer *pPlayer, CBaseCombatWeapon *pWeapon )
{
bool bIsBeingGivenItem = false;
CCSPlayer *pCSPlayer = ToCSPlayer( pPlayer );
if ( pCSPlayer && pCSPlayer->IsBeingGivenItem() )
bIsBeingGivenItem = true;
if ( pPlayer->GetActiveWeapon() && pPlayer->IsNetClient() && !bIsBeingGivenItem )
{
// 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;
}
}
if ( pPlayer->IsBot() && !bIsBeingGivenItem )
{
return false;
}
if ( !GetAllowWeaponSwitch() )
{
return false;
}
return BaseClass::FShouldSwitchWeapon( pPlayer, pWeapon );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : allow -
//-----------------------------------------------------------------------------
void CCSGameRules::SetAllowWeaponSwitch( bool allow )
{
m_bAllowWeaponSwitch = allow;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CCSGameRules::GetAllowWeaponSwitch()
{
return m_bAllowWeaponSwitch;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pPlayer -
// Output : const char
//-----------------------------------------------------------------------------
const char *CCSGameRules::SetDefaultPlayerTeam( CBasePlayer *pPlayer )
{
Assert( pPlayer );
return BaseClass::SetDefaultPlayerTeam( pPlayer );
}
void CCSGameRules::LevelInitPreEntity()
{
BaseClass::LevelInitPreEntity();
// TODO for CZ-style hostages: TheHostageChatter->Precache();
}
void CCSGameRules::LevelInitPostEntity()
{
BaseClass::LevelInitPostEntity();
m_bLevelInitialized = false; // re-count CT and T start spots now that they exist
// Figure out from the entities in the map what kind of map this is (bomb run, prison escape, etc).
CheckMapConditions();
}
INetworkStringTable *g_StringTableBlackMarket = NULL;
void CCSGameRules::CreateCustomNetworkStringTables( void )
{
m_StringTableBlackMarket = g_StringTableBlackMarket;
if ( 0 )//mp_dynamicpricing.GetBool() )
{
m_bBlackMarket = BlackMarket_DownloadPrices();
if ( m_bBlackMarket == false )
{
Msg( "ERROR: mp_dynamicpricing set to 1 but couldn't download the price list!\n" );
}
}
else
{
m_bBlackMarket = false;
SetBlackMarketPrices( true );
}
}
float CCSGameRules::FlPlayerFallDamage( CBasePlayer *pPlayer )
{
float fFallVelocity = pPlayer->m_Local.m_flFallVelocity - CS_PLAYER_MAX_SAFE_FALL_SPEED;
float fallDamage = fFallVelocity * CS_DAMAGE_FOR_FALL_SPEED * 1.25;
if ( fallDamage > 0.0f )
{
// let the bots know
IGameEvent * event = gameeventmanager->CreateEvent( "player_falldamage" );
if ( event )
{
event->SetInt( "userid", pPlayer->GetUserID() );
event->SetFloat( "damage", fallDamage );
event->SetInt( "priority", 4 ); // HLTV event priority, not transmitted
gameeventmanager->FireEvent( event );
}
}
return fallDamage;
}
void CCSGameRules::ClientDisconnected( edict_t *pClient )
{
BaseClass::ClientDisconnected( pClient );
//=============================================================================
// HPE_BEGIN:
// [tj] Clear domination data when a player disconnects
//=============================================================================
CCSPlayer *pPlayer = ToCSPlayer( GetContainingEntity( pClient ) );
if ( pPlayer )
{
pPlayer->RemoveNemesisRelationships();
}
//=============================================================================
// HPE_END
//=============================================================================
CheckWinConditions();
}
// Called when game rules are destroyed by CWorld
void CCSGameRules::LevelShutdown()
{
int iLevelIndex = GetCSLevelIndex( STRING( gpGlobals->mapname ) );
if ( iLevelIndex != -1 )
{
g_iTerroristVictories[iLevelIndex] += m_iNumTerroristWins;
g_iCounterTVictories[iLevelIndex] += m_iNumCTWins;
}
BaseClass::LevelShutdown();
}
//---------------------------------------------------------------------------------------------------
/**
* Check if the scenario has been won/lost.
* Return true if the scenario is over, false if the scenario is still in progress
*/
bool CCSGameRules::CheckWinConditions( void )
{
if ( mp_ignore_round_win_conditions.GetBool() )
{
return false;
}
// If a winner has already been determined.. then get the heck out of here
if (m_iRoundWinStatus != WINNER_NONE)
{
// still check if we lost players to where we need to do a full reset next round...
int NumDeadCT, NumDeadTerrorist, NumAliveTerrorist, NumAliveCT;
InitializePlayerCounts( NumAliveTerrorist, NumAliveCT, NumDeadTerrorist, NumDeadCT );
bool bNeededPlayers = false;
NeededPlayersCheck( bNeededPlayers );
return true;
}
// Initialize the player counts..
int NumDeadCT, NumDeadTerrorist, NumAliveTerrorist, NumAliveCT;
InitializePlayerCounts( NumAliveTerrorist, NumAliveCT, NumDeadTerrorist, NumDeadCT );
/***************************** OTHER PLAYER's CHECK *********************************************************/
bool bNeededPlayers = false;
if ( NeededPlayersCheck( bNeededPlayers ) )
return false;
/****************************** ASSASINATION/VIP SCENARIO CHECK *******************************************************/
if ( VIPRoundEndCheck( bNeededPlayers ) )
return true;
/****************************** PRISON ESCAPE CHECK *******************************************************/
if ( PrisonRoundEndCheck() )
return true;
/****************************** BOMB CHECK ********************************************************/
if ( BombRoundEndCheck( bNeededPlayers ) )
return true;
/***************************** TEAM EXTERMINATION CHECK!! *********************************************************/
// CounterTerrorists won by virture of elimination
if ( TeamExterminationCheck( NumAliveTerrorist, NumAliveCT, NumDeadTerrorist, NumDeadCT, bNeededPlayers ) )
return true;
/******************************** HOSTAGE RESCUE CHECK ******************************************************/
if ( HostageRescueRoundEndCheck( bNeededPlayers ) )
return true;
// scenario not won - still in progress
return false;
}
bool CCSGameRules::NeededPlayersCheck( bool &bNeededPlayers )
{
// We needed players to start scoring
// Do we have them now?
if( !m_iNumSpawnableTerrorist || !m_iNumSpawnableCT )
{
Msg( "Game will not start until both teams have players.\n" );
UTIL_ClientPrintAll( HUD_PRINTCONSOLE, "#Game_scoring" );
bNeededPlayers = true;
m_bFirstConnected = false;
}
if ( !m_bFirstConnected && m_iNumSpawnableTerrorist && m_iNumSpawnableCT )
{
// Start the round immediately when the first person joins
// UTIL_LogPrintf( "World triggered \"Game_Commencing\"\n" );
m_bFreezePeriod = false; //Make sure we are not on the FreezePeriod.
m_bCompleteReset = true;
TerminateRound( 3.0f, Game_Commencing );
m_bFirstConnected = true;
return true;
}
return false;
}
void CCSGameRules::InitializePlayerCounts(
int &NumAliveTerrorist,
int &NumAliveCT,
int &NumDeadTerrorist,
int &NumDeadCT
)
{
NumAliveTerrorist = NumAliveCT = NumDeadCT = NumDeadTerrorist = 0;
m_iNumTerrorist = m_iNumCT = m_iNumSpawnableTerrorist = m_iNumSpawnableCT = 0;
m_iHaveEscaped = 0;
// Count how many dead players there are on each team.
for ( int iTeam=0; iTeam < GetNumberOfTeams(); iTeam++ )
{
CTeam *pTeam = GetGlobalTeam( iTeam );
for ( int iPlayer=0; iPlayer < pTeam->GetNumPlayers(); iPlayer++ )
{
CCSPlayer *pPlayer = ToCSPlayer( pTeam->GetPlayer( iPlayer ) );
Assert( pPlayer );
if ( !pPlayer )
continue;
Assert( pPlayer->GetTeamNumber() == pTeam->GetTeamNumber() );
switch ( pTeam->GetTeamNumber() )
{
case TEAM_CT:
m_iNumCT++;
if ( pPlayer->State_Get() != STATE_PICKINGCLASS )
m_iNumSpawnableCT++;
if ( pPlayer->m_lifeState != LIFE_ALIVE )
NumDeadCT++;
else
NumAliveCT++;
break;
case TEAM_TERRORIST:
m_iNumTerrorist++;
if ( pPlayer->State_Get() != STATE_PICKINGCLASS )
m_iNumSpawnableTerrorist++;
if ( pPlayer->m_lifeState != LIFE_ALIVE )
NumDeadTerrorist++;
else
NumAliveTerrorist++;
// Check to see if this guy escaped.
if ( pPlayer->m_bEscaped == true )
m_iHaveEscaped++;
break;
}
}
}
}
bool CCSGameRules::HostageRescueRoundEndCheck( bool bNeededPlayers )
{
// Check to see if 50% of the hostages have been rescued.
CHostage* hostage = NULL;
int iNumHostages = g_Hostages.Count();
int iNumLeftToRescue = 0;
int i;
for ( i=0; i<iNumHostages; i++ )
{
hostage = g_Hostages[i];
if ( hostage->m_iHealth > 0 && !hostage->IsRescued() ) // We've found a live hostage. don't end the round
iNumLeftToRescue++;
}
m_iHostagesRemaining = iNumLeftToRescue;
if ( (iNumLeftToRescue == 0) && (iNumHostages > 0) )
{
if ( m_iHostagesRescued >= (iNumHostages * 0.5) )
{
m_iAccountCT += 2500;
if ( !bNeededPlayers )
{
m_iNumCTWins ++;
// Update the clients team score
UpdateTeamScores();
}
CCS_GameStats.Event_AllHostagesRescued();
// tell the bots all the hostages have been rescued
IGameEvent * event = gameeventmanager->CreateEvent( "hostage_rescued_all" );
if ( event )
{
gameeventmanager->FireEvent( event );
}
TerminateRound( mp_round_restart_delay.GetFloat(), All_Hostages_Rescued );
return true;
}
}
return false;
}
bool CCSGameRules::PrisonRoundEndCheck()
{
//MIKETODO: get this working when working on prison escape
/*
if (m_bMapHasEscapeZone == true)
{
float flEscapeRatio;
flEscapeRatio = (float) m_iHaveEscaped / (float) m_iNumEscapers;
if (flEscapeRatio >= m_flRequiredEscapeRatio)
{
BroadcastSound( "Event.TERWin" );
m_iAccountTerrorist += 3150;
if ( !bNeededPlayers )
{
m_iNumTerroristWins ++;
// Update the clients team score
UpdateTeamScores();
}
EndRoundMessage( "#Terrorists_Escaped", Terrorists_Escaped );
TerminateRound( mp_round_restart_delay.GetFloat(), WINNER_TER );
return;
}
else if ( NumAliveTerrorist == 0 && flEscapeRatio < m_flRequiredEscapeRatio)
{
BroadcastSound( "Event.CTWin" );
m_iAccountCT += (1 - flEscapeRatio) * 3500; // CTs are rewarded based on how many terrorists have escaped...
if ( !bNeededPlayers )
{
m_iNumCTWins++;
// Update the clients team score
UpdateTeamScores();
}
EndRoundMessage( "#CTs_PreventEscape", CTs_PreventEscape );
TerminateRound( mp_round_restart_delay.GetFloat(), WINNER_CT );
return;
}
else if ( NumAliveTerrorist == 0 && NumDeadTerrorist != 0 && m_iNumSpawnableCT > 0 )
{
BroadcastSound( "Event.CTWin" );
m_iAccountCT += (1 - flEscapeRatio) * 3250; // CTs are rewarded based on how many terrorists have escaped...
if ( !bNeededPlayers )
{
m_iNumCTWins++;
// Update the clients team score
UpdateTeamScores();
}
EndRoundMessage( "#Escaping_Terrorists_Neutralized", Escaping_Terrorists_Neutralized );
TerminateRound( mp_round_restart_delay.GetFloat(), WINNER_CT );
return;
}
// else return;
}
*/
return false;
}
bool CCSGameRules::VIPRoundEndCheck( bool bNeededPlayers )
{
if (m_iMapHasVIPSafetyZone != 1)
return false;
if (m_pVIP == NULL)
return false;
if (m_pVIP->m_bEscaped == true)
{
m_iAccountCT += 3500;
if ( !bNeededPlayers )
{
m_iNumCTWins ++;
// Update the clients team score
UpdateTeamScores();
}
//MIKETODO: get this working when working on VIP scenarios
/*
MessageBegin( MSG_SPEC, SVC_DIRECTOR );
WRITE_BYTE ( 9 ); // command length in bytes
WRITE_BYTE ( DRC_CMD_EVENT ); // VIP rescued
WRITE_SHORT( ENTINDEX(m_pVIP->edict()) ); // index number of primary entity
WRITE_SHORT( 0 ); // index number of secondary entity
WRITE_LONG( 15 | DRC_FLAG_FINAL); // eventflags (priority and flags)
MessageEnd();
*/
// tell the bots the VIP got out
IGameEvent * event = gameeventmanager->CreateEvent( "vip_escaped" );
if ( event )
{
event->SetInt( "userid", m_pVIP->GetUserID() );
event->SetInt( "priority", 9 );
gameeventmanager->FireEvent( event );
}
//=============================================================================
// HPE_BEGIN:
// [menglish] If the VIP has escaped award him an MVP
//=============================================================================
m_pVIP->IncrementNumMVPs( CSMVP_UNDEFINED );
//=============================================================================
// HPE_END
//=============================================================================
TerminateRound( mp_round_restart_delay.GetFloat(), VIP_Escaped );
return true;
}
else if ( m_pVIP->m_lifeState == LIFE_DEAD ) // The VIP is dead
{
m_iAccountTerrorist += 3250;
if ( !bNeededPlayers )
{
m_iNumTerroristWins ++;
// Update the clients team score
UpdateTeamScores();
}
// tell the bots the VIP was killed
IGameEvent * event = gameeventmanager->CreateEvent( "vip_killed" );
if ( event )
{
event->SetInt( "userid", m_pVIP->GetUserID() );
event->SetInt( "priority", 9 );
gameeventmanager->FireEvent( event );
}
TerminateRound( mp_round_restart_delay.GetFloat(), VIP_Assassinated );
return true;
}
return false;
}
bool CCSGameRules::BombRoundEndCheck( bool bNeededPlayers )
{
// Check to see if the bomb target was hit or the bomb defused.. if so, then let's end the round!
if ( ( m_bTargetBombed == true ) && ( m_bMapHasBombTarget == true ) )
{
m_iAccountTerrorist += 3500;
if ( !bNeededPlayers )
{
m_iNumTerroristWins ++;
// Update the clients team score
UpdateTeamScores();
}
TerminateRound( mp_round_restart_delay.GetFloat(), Target_Bombed );
return true;
}
else
if ( ( m_bBombDefused == true ) && ( m_bMapHasBombTarget == true ) )
{
m_iAccountCT += 3250;
m_iAccountTerrorist += 800; // give the T's a little bonus for planting the bomb even though it was defused.
if ( !bNeededPlayers )
{
m_iNumCTWins++;
// Update the clients team score
UpdateTeamScores();
}
TerminateRound( mp_round_restart_delay.GetFloat(), Bomb_Defused );
return true;
}
return false;
}
bool CCSGameRules::TeamExterminationCheck(
int NumAliveTerrorist,
int NumAliveCT,
int NumDeadTerrorist,
int NumDeadCT,
bool bNeededPlayers
)
{
if ( ( m_iNumCT > 0 && m_iNumSpawnableCT > 0 ) && ( m_iNumTerrorist > 0 && m_iNumSpawnableTerrorist > 0 ) )
{
if ( NumAliveTerrorist == 0 && NumDeadTerrorist != 0 && m_iNumSpawnableCT > 0 )
{
bool nowin = false;
for ( int iGrenade=0; iGrenade < g_PlantedC4s.Count(); iGrenade++ )
{
CPlantedC4 *pC4 = g_PlantedC4s[iGrenade];
if ( pC4->IsBombActive() )
nowin = true;
}
if ( !nowin )
{
if ( m_bMapHasBombTarget )
m_iAccountCT += 3250;
else
m_iAccountCT += 3000;
if ( !bNeededPlayers )
{
m_iNumCTWins++;
// Update the clients team score
UpdateTeamScores();
}
TerminateRound( mp_round_restart_delay.GetFloat(), CTs_Win );
return true;
}
}
// Terrorists WON
if ( NumAliveCT == 0 && NumDeadCT != 0 && m_iNumSpawnableTerrorist > 0 )
{
if ( m_bMapHasBombTarget )
m_iAccountTerrorist += 3250;
else
m_iAccountTerrorist += 3000;
if ( !bNeededPlayers )
{
m_iNumTerroristWins++;
// Update the clients team score
UpdateTeamScores();
}
TerminateRound( mp_round_restart_delay.GetFloat(), Terrorists_Win );
return true;
}
}
else if ( NumAliveCT == 0 && NumAliveTerrorist == 0 )
{
TerminateRound( mp_round_restart_delay.GetFloat(), Round_Draw );
return true;
}
return false;
}
void CCSGameRules::PickNextVIP()
{
// MIKETODO: work on this when getting VIP maps running.
/*
if (IsVIPQueueEmpty() != true)
{
// Remove the current VIP from his VIP status and make him a regular CT.
if (m_pVIP != NULL)
ResetCurrentVIP();
for (int i = 0; i <= 4; i++)
{
if (VIPQueue[i] != NULL)
{
m_pVIP = VIPQueue[i];
m_pVIP->MakeVIP();
VIPQueue[i] = NULL; // remove this player from the VIP queue
StackVIPQueue(); // and re-organize the queue
m_iConsecutiveVIP = 0;
return;
}
}
}
else if (m_iConsecutiveVIP >= 3) // If it's been the same VIP for 3 rounds already.. then randomly pick a new one
{
m_iLastPick++;
if (m_iLastPick > m_iNumCT)
m_iLastPick = 1;
int iCount = 1;
CBaseEntity* pPlayer = NULL;
CBasePlayer* player = NULL;
CBasePlayer* pLastPlayer = NULL;
pPlayer = UTIL_FindEntityByClassname ( pPlayer, "player" );
while ( (pPlayer != NULL) && (!FNullEnt(pPlayer->edict())) )
{
if ( !(pPlayer->pev->flags & FL_DORMANT) )
{
player = GetClassPtr((CBasePlayer *)pPlayer->pev);
if ( (player->m_iTeam == CT) && (iCount == m_iLastPick) )
{
if ( (player == m_pVIP) && (pLastPlayer != NULL) )
player = pLastPlayer;
// Remove the current VIP from his VIP status and make him a regular CT.
if (m_pVIP != NULL)
ResetCurrentVIP();
player->MakeVIP();
m_iConsecutiveVIP = 0;
return;
}
else if ( player->m_iTeam == CT )
iCount++;
if ( player->m_iTeam != SPECTATOR )
pLastPlayer = player;
}
pPlayer = UTIL_FindEntityByClassname ( pPlayer, "player" );
}
}
else if (m_pVIP == NULL) // There is no VIP and there is no one waiting to be the VIP.. therefore just pick the first CT player we can find.
{
CBaseEntity* pPlayer = NULL;
CBasePlayer* player = NULL;
pPlayer = UTIL_FindEntityByClassname ( pPlayer, "player" );
while ( (pPlayer != NULL) && (!FNullEnt(pPlayer->edict())) )
{
if ( pPlayer->pev->flags != FL_DORMANT )
{
player = GetClassPtr((CBasePlayer *)pPlayer->pev);
if ( player->m_iTeam == CT )
{
player->MakeVIP();
m_iConsecutiveVIP = 0;
return;
}
}
pPlayer = UTIL_FindEntityByClassname ( pPlayer, "player" );
}
}
*/
}
void CCSGameRules::ReadMultiplayCvars()
{
m_iRoundTime = (int)(mp_roundtime.GetFloat() * 60);
m_iFreezeTime = mp_freezetime.GetInt();
}
void CCSGameRules::RestartRound()
{
#if defined( REPLAY_ENABLED )
if ( g_pReplay )
{
// Write replay and stop recording if appropriate
if ( g_pReplay->IsRecording() )
{
g_pReplay->SV_EndRecordingSession();
}
int nActivePlayerCount = m_iNumTerrorist + m_iNumCT;
if ( nActivePlayerCount && g_pReplay->SV_ShouldBeginRecording( false ) )
{
// Tell the replay manager that it should begin recording the new round as soon as possible
g_pReplay->SV_GetContext()->GetSessionRecorder()->StartRecording();
}
}
#endif
//=============================================================================
// HPE_BEGIN:
// [tj] Notify players that the round is about to be reset
//=============================================================================
for ( int clientIndex = 1; clientIndex <= gpGlobals->maxClients; clientIndex++ )
{
CCSPlayer *pPlayer = (CCSPlayer*) UTIL_PlayerByIndex( clientIndex );
if(pPlayer)
{
pPlayer->OnPreResetRound();
}
}
//=============================================================================
// HPE_END
//=============================================================================
if ( !IsFinite( gpGlobals->curtime ) )
{
Warning( "NaN curtime in RestartRound\n" );
gpGlobals->curtime = 0.0f;
}
int i;
m_iTotalRoundsPlayed++;
//ClearBodyQue();
// Hardlock the player accelaration to 5.0
//CVAR_SET_FLOAT( "sv_accelerate", 5.0 );
//CVAR_SET_FLOAT( "sv_friction", 4.0 );
//CVAR_SET_FLOAT( "sv_stopspeed", 75 );
sv_stopspeed.SetValue( 75.0f );
// Tabulate the number of players on each team.
int NumDeadCT, NumDeadTerrorist, NumAliveTerrorist, NumAliveCT;
InitializePlayerCounts( NumAliveTerrorist, NumAliveCT, NumDeadTerrorist, NumDeadCT );
m_bBombDropped = false;
m_bBombPlanted = false;
if ( GetHumanTeam() != TEAM_UNASSIGNED )
{
MoveHumansToHumanTeam();
}
/*************** AUTO-BALANCE CODE *************/
if ( mp_autoteambalance.GetInt() != 0 &&
(m_iUnBalancedRounds >= 1) )
{
if ( GetHumanTeam() == TEAM_UNASSIGNED )
{
BalanceTeams();
}
}
if ( ((m_iNumSpawnableCT - m_iNumSpawnableTerrorist) >= 2) ||
((m_iNumSpawnableTerrorist - m_iNumSpawnableCT) >= 2) )
{
m_iUnBalancedRounds++;
}
else
{
m_iUnBalancedRounds = 0;
}
// Warn the players of an impending auto-balance next round...
if ( mp_autoteambalance.GetInt() != 0 &&
(m_iUnBalancedRounds == 1) )
{
if ( GetHumanTeam() == TEAM_UNASSIGNED )
{
UTIL_ClientPrintAll( HUD_PRINTCENTER,"#Auto_Team_Balance_Next_Round");
}
}
/*************** AUTO-BALANCE CODE *************/
if ( m_bCompleteReset )
{
// 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;
}
// Reset total # of rounds played
m_iTotalRoundsPlayed = 0;
// Reset score info
m_iNumTerroristWins = 0;
m_iNumCTWins = 0;
m_iNumConsecutiveTerroristLoses = 0;
m_iNumConsecutiveCTLoses = 0;
// Reset team scores
UpdateTeamScores();
// Reset the player stats
for ( i = 1; i <= gpGlobals->maxClients; i++ )
{
CCSPlayer *pPlayer = CCSPlayer::Instance( i );
if ( pPlayer && !FNullEnt( pPlayer->edict() ) )
pPlayer->Reset();
}
}
m_bFreezePeriod = true;
ReadMultiplayCvars();
// Check to see if there's a mapping info paramater entity
if ( g_pMapInfo )
{
switch ( g_pMapInfo->m_iBuyingStatus )
{
case 0:
m_bCTCantBuy = false;
m_bTCantBuy = false;
Msg( "EVERYONE CAN BUY!\n" );
break;
case 1:
m_bCTCantBuy = false;
m_bTCantBuy = true;
Msg( "Only CT's can buy!!\n" );
break;
case 2:
m_bCTCantBuy = true;
m_bTCantBuy = false;
Msg( "Only T's can buy!!\n" );
break;
case 3:
m_bCTCantBuy = true;
m_bTCantBuy = true;
Msg( "No one can buy!!\n" );
break;
default:
m_bCTCantBuy = false;
m_bTCantBuy = false;
break;
}
}
else
{
// by default everyone can buy
m_bCTCantBuy = false;
m_bTCantBuy = false;
}
// Check to see if this map has a bomb target in it
if ( gEntList.FindEntityByClassname( NULL, "func_bomb_target" ) )
{
m_bMapHasBombTarget = true;
m_bMapHasBombZone = true;
}
else if ( gEntList.FindEntityByClassname( NULL, "info_bomb_target" ) )
{
m_bMapHasBombTarget = true;
m_bMapHasBombZone = false;
}
else
{
m_bMapHasBombTarget = false;
m_bMapHasBombZone = false;
}
// Check to see if this map has hostage rescue zones
if ( gEntList.FindEntityByClassname( NULL, "func_hostage_rescue" ) )
m_bMapHasRescueZone = true;
else
m_bMapHasRescueZone = false;
// See if the map has func_buyzone entities
// Used by CBasePlayer::HandleSignals() to support maps without these entities
if ( gEntList.FindEntityByClassname( NULL, "func_buyzone" ) )
m_bMapHasBuyZone = true;
else
m_bMapHasBuyZone = false;
// GOOSEMAN : See if this map has func_escapezone entities
if ( gEntList.FindEntityByClassname( NULL, "func_escapezone" ) )
{
m_bMapHasEscapeZone = true;
m_iHaveEscaped = 0;
m_iNumEscapers = 0; // Will increase this later when we count how many Ts are starting
if (m_iNumEscapeRounds >= 3)
{
SwapAllPlayers();
m_iNumEscapeRounds = 0;
}
m_iNumEscapeRounds++; // Increment the number of rounds played... After 8 rounds, the players will do a whole sale switch..
}
else
m_bMapHasEscapeZone = false;
// Check to see if this map has VIP safety zones
if ( gEntList.FindEntityByClassname( NULL, "func_vip_safetyzone" ) )
{
PickNextVIP();
m_iConsecutiveVIP++;
m_iMapHasVIPSafetyZone = 1;
}
else
m_iMapHasVIPSafetyZone = 2;
// Update accounts based on number of hostages remaining..
int iRescuedHostageBonus = 0;
for ( int iHostage=0; iHostage < g_Hostages.Count(); iHostage++ )
{
CHostage *pHostage = g_Hostages[iHostage];
if( pHostage->IsRescuable() ) //Alive and not rescued
{
iRescuedHostageBonus += 150;
}
if ( iRescuedHostageBonus >= 2000 )
break;
}
//*******Catch up code by SupraFiend. Scale up the loser bonus when teams fall into losing streaks
if (m_iRoundWinStatus == WINNER_TER) // terrorists won
{
//check to see if they just broke a losing streak
if(m_iNumConsecutiveTerroristLoses > 1)
m_iLoserBonus = 1500;//this is the default losing bonus
m_iNumConsecutiveTerroristLoses = 0;//starting fresh
m_iNumConsecutiveCTLoses++;//increment the number of wins the CTs have had
}
else if (m_iRoundWinStatus == WINNER_CT) // CT Won
{
//check to see if they just broke a losing streak
if(m_iNumConsecutiveCTLoses > 1)
m_iLoserBonus = 1500;//this is the default losing bonus
m_iNumConsecutiveCTLoses = 0;//starting fresh
m_iNumConsecutiveTerroristLoses++;//increment the number of wins the Terrorists have had
}
//check if the losing team is in a losing streak & that the loser bonus hasen't maxed out.
if((m_iNumConsecutiveTerroristLoses > 1) && (m_iLoserBonus < 3000))
m_iLoserBonus += 500;//help out the team in the losing streak
else
if((m_iNumConsecutiveCTLoses > 1) && (m_iLoserBonus < 3000))
m_iLoserBonus += 500;//help out the team in the losing streak
// assign the wining and losing bonuses
if (m_iRoundWinStatus == WINNER_TER) // terrorists won
{
m_iAccountTerrorist += iRescuedHostageBonus;
m_iAccountCT += m_iLoserBonus;
}
else if (m_iRoundWinStatus == WINNER_CT) // CT Won
{
m_iAccountCT += iRescuedHostageBonus;
if (m_bMapHasEscapeZone == false) // only give them the bonus if this isn't an escape map
m_iAccountTerrorist += m_iLoserBonus;
}
//Update CT account based on number of hostages rescued
m_iAccountCT += m_iHostagesRescued * 750;
// Update individual players accounts and respawn players
//**********new code by SupraFiend
//##########code changed by MartinO
//the round time stamp must be set before players are spawned
m_fRoundStartTime = gpGlobals->curtime + m_iFreezeTime;
if ( !IsFinite( m_fRoundStartTime.Get() ) )
{
Warning( "Trying to set a NaN round start time\n" );
m_fRoundStartTime.GetForModify() = 0.0f;
}
//Adrian - No cash for anyone at first rounds! ( well, only the default. )
if ( m_bCompleteReset )
{
m_iAccountTerrorist = m_iAccountCT = 0; //No extra cash!.
//We are starting fresh. So it's like no one has ever won or lost.
m_iNumTerroristWins = 0;
m_iNumCTWins = 0;
m_iNumConsecutiveTerroristLoses = 0;
m_iNumConsecutiveCTLoses = 0;
m_iLoserBonus = 1400;
}
for ( i = 1; i <= gpGlobals->maxClients; i++ )
{
CCSPlayer *pPlayer = (CCSPlayer*) UTIL_PlayerByIndex( i );
if ( !pPlayer )
continue;
pPlayer->m_iNumSpawns = 0;
pPlayer->m_bTeamChanged = false;
if ( pPlayer->GetTeamNumber() == TEAM_CT )
{
if (pPlayer->DoesPlayerGetRoundStartMoney())
{
pPlayer->AddAccount( m_iAccountCT );
}
}
else if ( pPlayer->GetTeamNumber() == TEAM_TERRORIST )
{
m_iNumEscapers++; // Add another potential escaper to the mix!
if (pPlayer->DoesPlayerGetRoundStartMoney())
{
pPlayer->AddAccount( m_iAccountTerrorist );
}
}
// tricky, make players non solid while moving to their spawn points
if ( (pPlayer->GetTeamNumber() == TEAM_CT) || (pPlayer->GetTeamNumber() == TEAM_TERRORIST) )
{
pPlayer->AddSolidFlags( FSOLID_NOT_SOLID );
}
}
//=============================================================================
// HPE_BEGIN:
// [tj] Keep track of number of players per side and if they have the same uniform
//=============================================================================
int terroristUniform = -1;
bool allTerroristsWearingSameUniform = true;
int numberOfTerrorists = 0;
int ctUniform = -1;
bool allCtsWearingSameUniform = true;
int numberOfCts = 0;
//=============================================================================
// HPE_END
//=============================================================================
// know respawn all players
for ( i = 1; i <= gpGlobals->maxClients; i++ )
{
CCSPlayer *pPlayer = (CCSPlayer*) UTIL_PlayerByIndex( i );
if ( !pPlayer )
continue;
if ( pPlayer->GetTeamNumber() == TEAM_CT && pPlayer->PlayerClass() >= FIRST_CT_CLASS && pPlayer->PlayerClass() <= LAST_CT_CLASS )
{
//=============================================================================
// HPE_BEGIN:
// [tj] Increment CT count and check CT uniforms.
//=============================================================================
numberOfCts++;
if (ctUniform == -1)
{
ctUniform = pPlayer->PlayerClass();
}
else if (pPlayer->PlayerClass() != ctUniform)
{
allCtsWearingSameUniform = false;
}
//=============================================================================
// HPE_END
//=============================================================================
pPlayer->RoundRespawn();
}
if ( pPlayer->GetTeamNumber() == TEAM_TERRORIST && pPlayer->PlayerClass() >= FIRST_T_CLASS && pPlayer->PlayerClass() <= LAST_T_CLASS )
{
//=============================================================================
// HPE_BEGIN:
// [tj] Increment terrorist count and check terrorist uniforms
//=============================================================================
numberOfTerrorists++;
if (terroristUniform == -1)
{
terroristUniform = pPlayer->PlayerClass();
}
else if (pPlayer->PlayerClass() != terroristUniform)
{
allTerroristsWearingSameUniform = false;
}
//=============================================================================
// HPE_END
//=============================================================================
pPlayer->RoundRespawn();
}
else
{
pPlayer->ObserverRoundRespawn();
}
if ( pPlayer->m_iAccount > pPlayer->m_iShouldHaveCash )
{
m_bDontUploadStats = true;
}
}
//=============================================================================
// HPE_BEGIN:
//=============================================================================
// [tj] Award same uniform achievement for qualifying teams
for ( i = 1; i <= gpGlobals->maxClients; i++ )
{
CCSPlayer *pPlayer = (CCSPlayer*) UTIL_PlayerByIndex( i );
if ( !pPlayer )
continue;
if ( pPlayer->GetTeamNumber() == TEAM_CT && allCtsWearingSameUniform && numberOfCts >= AchievementConsts::SameUniform_MinPlayers)
{
pPlayer->AwardAchievement(CSSameUniform);
}
if ( pPlayer->GetTeamNumber() == TEAM_TERRORIST && allTerroristsWearingSameUniform && numberOfTerrorists >= AchievementConsts::SameUniform_MinPlayers)
{
pPlayer->AwardAchievement(CSSameUniform);
}
}
// [menglish] reset per-round achievement variables for each player
for ( i = 1; i <= gpGlobals->maxClients; i++ )
{
CCSPlayer *pPlayer = (CCSPlayer*) UTIL_PlayerByIndex( i );
if( pPlayer )
{
pPlayer->ResetRoundBasedAchievementVariables();
}
}
// [pfreese] Reset all round or match stats, depending on type of restart
if ( m_bCompleteReset )
{
CCS_GameStats.ResetAllStats();
CCS_GameStats.ResetPlayerClassMatchStats();
}
else
{
CCS_GameStats.ResetRoundStats();
}
//=============================================================================
// HPE_END
//=============================================================================
// Respawn entities (glass, doors, etc..)
CleanUpMap();
// now run a tkpunish check, after the map has been cleaned up
for ( i = 1; i <= gpGlobals->maxClients; i++ )
{
CCSPlayer *pPlayer = (CCSPlayer*) UTIL_PlayerByIndex( i );
if ( !pPlayer )
continue;
if ( pPlayer->GetTeamNumber() == TEAM_CT && pPlayer->PlayerClass() >= FIRST_CT_CLASS && pPlayer->PlayerClass() <= LAST_CT_CLASS )
{
pPlayer->CheckTKPunishment();
}
if ( pPlayer->GetTeamNumber() == TEAM_TERRORIST && pPlayer->PlayerClass() >= FIRST_T_CLASS && pPlayer->PlayerClass() <= LAST_T_CLASS )
{
pPlayer->CheckTKPunishment();
}
}
// Give C4 to the terrorists
if (m_bMapHasBombTarget == true )
GiveC4();
// Reset game variables
m_flIntermissionEndTime = 0;
m_flRestartRoundTime = 0.0;
m_iAccountTerrorist = m_iAccountCT = 0;
m_iHostagesRescued = 0;
m_iHostagesTouched = 0;
//=============================================================================
// HPE_BEGIN
// [dwenger] Reset rescue-related achievement values
//=============================================================================
// [tj] reset flawless and lossless round related flags
m_bNoTerroristsKilled = true;
m_bNoCTsKilled = true;
m_bNoTerroristsDamaged = true;
m_bNoCTsDamaged = true;
m_pFirstKill = NULL;
m_pFirstBlood = NULL;
m_bCanDonateWeapons = true;
// [dwenger] Reset rescue-related achievement values
m_iHostagesRemaining = 0;
m_pLastRescuer = NULL;
m_hostageWasInjured = false;
m_hostageWasKilled = false;
//=============================================================================
// HPE_END
//=============================================================================
m_iNumRescuers = 0;
m_iRoundWinStatus = WINNER_NONE;
m_bTargetBombed = m_bBombDefused = false;
m_bCompleteReset = false;
m_flNextHostageAnnouncement = gpGlobals->curtime;
m_iHostagesRemaining = g_Hostages.Count();
// fire global game event
IGameEvent * event = gameeventmanager->CreateEvent( "round_start" );
if ( event )
{
event->SetInt("timelimit", m_iRoundTime );
event->SetInt("fraglimit", 0 );
event->SetInt( "priority", 6 ); // HLTV event priority, not transmitted
if ( m_bMapHasRescueZone )
{
event->SetString("objective","HOSTAGE RESCUE");
}
else if ( m_bMapHasEscapeZone )
{
event->SetString("objective","PRISON ESCAPE");
}
else if ( m_iMapHasVIPSafetyZone == 1 )
{
event->SetString("objective","VIP RESCUE");
}
else if ( m_bMapHasBombTarget || m_bMapHasBombZone )
{
event->SetString("objective","BOMB TARGET");
}
else
{
event->SetString("objective","DEATHMATCH");
}
gameeventmanager->FireEvent( event );
}
UploadGameStats();
//=============================================================================
// HPE_BEGIN:
// [pfreese] I commented out this call to CreateWeaponManager, as the
// CGameWeaponManager object doesn't appear to be actually used by the CSS
// code, and in any case, the weapon manager does not support wildcards in
// entity names (as seemingly indicated) below. When the manager fails to
// create its factory, it removes itself in any case.
//=============================================================================
// CreateWeaponManager( "weapon_*", gpGlobals->maxClients * 2 );
//=============================================================================
// HPE_END
//=============================================================================
}
void CCSGameRules::GiveC4()
{
enum {
ALL_TERRORISTS = 0,
HUMAN_TERRORISTS,
};
int iTerrorists[2][ABSOLUTE_PLAYER_LIMIT];
int numAliveTs[2] = { 0, 0 };
int lastBombGuyIndex[2] = { -1, -1 };
//Create an array of the indeces of bomb carrier candidates
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CCSPlayer *pPlayer = ToCSPlayer( UTIL_PlayerByIndex( i ) );
if( pPlayer && pPlayer->IsAlive() && pPlayer->GetTeamNumber() == TEAM_TERRORIST && numAliveTs[ALL_TERRORISTS] < ABSOLUTE_PLAYER_LIMIT )
{
if ( pPlayer == m_pLastBombGuy )
{
lastBombGuyIndex[ALL_TERRORISTS] = numAliveTs[ALL_TERRORISTS];
lastBombGuyIndex[HUMAN_TERRORISTS] = numAliveTs[HUMAN_TERRORISTS];
}
iTerrorists[ALL_TERRORISTS][numAliveTs[ALL_TERRORISTS]] = i;
numAliveTs[ALL_TERRORISTS]++;
if ( !pPlayer->IsBot() )
{
iTerrorists[HUMAN_TERRORISTS][numAliveTs[HUMAN_TERRORISTS]] = i;
numAliveTs[HUMAN_TERRORISTS]++;
}
}
}
int which = cv_bot_defer_to_human.GetBool();
if ( numAliveTs[HUMAN_TERRORISTS] == 0 )
{
which = ALL_TERRORISTS;
}
//pick one of the candidates randomly
if( numAliveTs[which] > 0 )
{
int index = random->RandomInt(0,numAliveTs[which]-1);
if ( lastBombGuyIndex[which] >= 0 )
{
// give the C4 sequentially
index = (lastBombGuyIndex[which] + 1) % numAliveTs[which];
}
CCSPlayer *pPlayer = ToCSPlayer( UTIL_PlayerByIndex( iTerrorists[which][index] ) );
Assert( pPlayer && pPlayer->GetTeamNumber() == TEAM_TERRORIST && pPlayer->IsAlive() );
pPlayer->GiveNamedItem( WEAPON_C4_CLASSNAME );
m_pLastBombGuy = pPlayer;
//pPlayer->SetBombIcon();
//pPlayer->pev->body = 1;
pPlayer->m_iDisplayHistoryBits |= DHF_BOMB_RETRIEVED;
pPlayer->HintMessage( "#Hint_you_have_the_bomb", false, true );
// Log this information
//UTIL_LogPrintf("\"%s<%i><%s><TERRORIST>\" triggered \"Spawned_With_The_Bomb\"\n",
// STRING( pPlayer->GetPlayerName() ),
// GETPLAYERUSERID( pPlayer->edict() ),
// GETPLAYERAUTHID( pPlayer->edict() ) );
}
m_bBombDropped = false;
}
void CCSGameRules::Think()
{
CGameRules::Think();
for ( int i = 0; i < GetNumberOfTeams(); i++ )
{
GetGlobalTeam( i )->Think();
}
///// Check game rules /////
if ( CheckGameOver() )
{
return;
}
// have we hit the max rounds?
if ( CheckMaxRounds() )
{
return;
}
// did somebaody hit the fraglimit ?
if ( CheckFragLimit() )
{
return;
}
if ( CheckWinLimit() )
{
return;
}
// Check for the end of the round.
if ( IsFreezePeriod() )
{
CheckFreezePeriodExpired();
}
else
{
CheckRoundTimeExpired();
}
CheckLevelInitialized();
if ( m_flRestartRoundTime > 0.0f && m_flRestartRoundTime <= gpGlobals->curtime )
{
bool botSpeaking = false;
for ( int i=1; i <= gpGlobals->maxClients; ++i )
{
CBasePlayer *player = UTIL_PlayerByIndex( i );
if (player == NULL)
continue;
if (!player->IsBot())
continue;
CCSBot *bot = dynamic_cast< CCSBot * >(player);
if ( !bot )
continue;
if ( bot->IsUsingVoice() )
{
if ( gpGlobals->curtime > m_flRestartRoundTime + 10.0f )
{
Msg( "Ignoring speaking bot %s at round end\n", bot->GetPlayerName() );
}
else
{
botSpeaking = true;
break;
}
}
}
if ( !botSpeaking )
{
RestartRound();
}
}
if ( gpGlobals->curtime > m_tmNextPeriodicThink )
{
CheckRestartRound();
m_tmNextPeriodicThink = gpGlobals->curtime + 1.0;
}
}
// The bots do their processing after physics simulation etc so their visibility checks don't recompute
// bone positions multiple times a frame.
void CCSGameRules::EndGameFrame( void )
{
TheBots->StartFrame();
BaseClass::EndGameFrame();
}
bool CCSGameRules::CheckGameOver()
{
if ( g_fGameOver ) // someone else quit the game already
{
//=============================================================================
// HPE_BEGIN:
// [Forrest] Calling ChangeLevel multiple times was causing IncrementMapCycleIndex
// to skip over maps in the list. Avoid this using a technique from CTeamplayRoundBasedRules::Think.
//=============================================================================
// check to see if we should change levels now
if ( m_flIntermissionEndTime && ( m_flIntermissionEndTime < gpGlobals->curtime ) )
{
ChangeLevel(); // intermission is over
// Don't run this code again
m_flIntermissionEndTime = 0.f;
}
//=============================================================================
// HPE_END
//=============================================================================
return true;
}
return false;
}
bool CCSGameRules::CheckFragLimit()
{
if ( fraglimit.GetInt() <= 0 )
return false;
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
if ( pPlayer && pPlayer->FragCount() >= fraglimit.GetInt() )
{
const char *teamName = "UNKNOWN";
if ( pPlayer->GetTeam() )
{
teamName = pPlayer->GetTeam()->GetName();
}
UTIL_LogPrintf("\"%s<%i><%s><%s>\" triggered \"Intermission_Kill_Limit\"\n",
pPlayer->GetPlayerName(),
pPlayer->GetUserID(),
pPlayer->GetNetworkIDString(),
teamName
);
GoToIntermission();
return true;
}
}
return false;
}
bool CCSGameRules::CheckMaxRounds()
{
if ( mp_maxrounds.GetInt() != 0 )
{
if ( m_iTotalRoundsPlayed >= mp_maxrounds.GetInt() )
{
UTIL_LogPrintf("World triggered \"Intermission_Round_Limit\"\n");
GoToIntermission();
return true;
}
}
return false;
}
bool CCSGameRules::CheckWinLimit()
{
// has one team won the specified number of rounds?
if ( mp_winlimit.GetInt() != 0 )
{
if ( m_iNumCTWins >= mp_winlimit.GetInt() )
{
UTIL_LogPrintf("Team \"CT\" triggered \"Intermission_Win_Limit\"\n");
GoToIntermission();
return true;
}
if ( m_iNumTerroristWins >= mp_winlimit.GetInt() )
{
UTIL_LogPrintf("Team \"TERRORIST\" triggered \"Intermission_Win_Limit\"\n");
GoToIntermission();
return true;
}
}
return false;
}
void CCSGameRules::CheckFreezePeriodExpired()
{
float startTime = m_fRoundStartTime;
if ( !IsFinite( startTime ) )
{
Warning( "Infinite round start time!\n" );
m_fRoundStartTime.GetForModify() = gpGlobals->curtime;
}
if ( IsFinite( startTime ) && gpGlobals->curtime < startTime )
{
return; // not time yet to start round
}
// Log this information
UTIL_LogPrintf("World triggered \"Round_Start\"\n");
char CT_sentence[40];
char T_sentence[40];
switch ( random->RandomInt( 0, 3 ) )
{
case 0:
Q_strncpy(CT_sentence,"radio.moveout", sizeof( CT_sentence ) );
Q_strncpy(T_sentence ,"radio.moveout", sizeof( T_sentence ) );
break;
case 1:
Q_strncpy(CT_sentence, "radio.letsgo", sizeof( CT_sentence ) );
Q_strncpy(T_sentence , "radio.letsgo", sizeof( T_sentence ) );
break;
case 2:
Q_strncpy(CT_sentence , "radio.locknload", sizeof( CT_sentence ) );
Q_strncpy(T_sentence , "radio.locknload", sizeof( T_sentence ) );
break;
default:
Q_strncpy(CT_sentence , "radio.go", sizeof( CT_sentence ) );
Q_strncpy(T_sentence , "radio.go", sizeof( T_sentence ) );
break;
}
// More specific radio commands for the new scenarios : Prison & Assasination
if (m_bMapHasEscapeZone == TRUE)
{
Q_strncpy(CT_sentence , "radio.elim", sizeof( CT_sentence ) );
Q_strncpy(T_sentence , "radio.getout", sizeof( T_sentence ) );
}
else if (m_iMapHasVIPSafetyZone == 1)
{
Q_strncpy(CT_sentence , "radio.vip", sizeof( CT_sentence ) );
Q_strncpy(T_sentence , "radio.locknload", sizeof( T_sentence ) );
}
// Freeze period expired: kill the flag
m_bFreezePeriod = false;
IGameEvent * event = gameeventmanager->CreateEvent( "round_freeze_end" );
if ( event )
{
gameeventmanager->FireEvent( event );
}
// Update the timers for all clients and play a sound
bool bCTPlayed = false;
bool bTPlayed = false;
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CCSPlayer *pPlayer = CCSPlayer::Instance( i );
if ( pPlayer && !FNullEnt( pPlayer->edict() ) )
{
if ( pPlayer->State_Get() == STATE_ACTIVE )
{
if ( (pPlayer->GetTeamNumber() == TEAM_CT) && !bCTPlayed )
{
pPlayer->Radio( CT_sentence );
bCTPlayed = true;
}
else if ( (pPlayer->GetTeamNumber() == TEAM_TERRORIST) && !bTPlayed )
{
pPlayer->Radio( T_sentence );
bTPlayed = true;
}
}
//pPlayer->SyncRoundTimer();
}
}
}
void CCSGameRules::CheckRoundTimeExpired()
{
if ( mp_ignore_round_win_conditions.GetBool() )
return;
if ( GetRoundRemainingTime() > 0 || m_iRoundWinStatus != WINNER_NONE )
return; //We haven't completed other objectives, so go for this!.
if( !m_bFirstConnected )
return;
// New code to get rid of round draws!!
if ( m_bMapHasBombTarget )
{
//If the bomb is planted, don't let the round timer end the round.
//keep going until the bomb explodes or is defused
if( !m_bBombPlanted )
{
m_iAccountCT += 3250;
m_iNumCTWins++;
TerminateRound( mp_round_restart_delay.GetFloat(), Target_Saved );
UpdateTeamScores();
MarkLivingPlayersOnTeamAsNotReceivingMoneyNextRound(TEAM_TERRORIST);
}
}
else if ( m_bMapHasRescueZone )
{
m_iAccountTerrorist += 3250;
m_iNumTerroristWins++;
TerminateRound( mp_round_restart_delay.GetFloat(), Hostages_Not_Rescued );
UpdateTeamScores();
MarkLivingPlayersOnTeamAsNotReceivingMoneyNextRound(TEAM_CT);
}
else if ( m_bMapHasEscapeZone )
{
m_iNumCTWins++;
TerminateRound( mp_round_restart_delay.GetFloat(), Terrorists_Not_Escaped );
UpdateTeamScores();
}
else if ( m_iMapHasVIPSafetyZone == 1 )
{
m_iAccountTerrorist += 3250;
m_iNumTerroristWins++;
TerminateRound( mp_round_restart_delay.GetFloat(), VIP_Not_Escaped );
UpdateTeamScores();
}
#if defined( REPLAY_ENABLED )
if ( g_pReplay )
{
// Write replay and stop recording if appropriate
g_pReplay->SV_EndRecordingSession();
}
#endif
}
void CCSGameRules::GoToIntermission( void )
{
Msg( "Going to intermission...\n" );
IGameEvent *winEvent = gameeventmanager->CreateEvent( "cs_win_panel_match" );
if( winEvent )
{
for ( int teamIndex = TEAM_TERRORIST; teamIndex <= TEAM_CT; teamIndex++ )
{
CTeam *team = GetGlobalTeam( teamIndex );
if ( team )
{
float kills = CCS_GameStats.GetTeamStats(teamIndex)[CSSTAT_KILLS];
float deaths = CCS_GameStats.GetTeamStats(teamIndex)[CSSTAT_DEATHS];
// choose dialog variables to set depending on team
switch ( teamIndex )
{
case TEAM_TERRORIST:
winEvent->SetInt( "t_score", team->GetScore() );
if(deaths == 0)
{
winEvent->SetFloat( "t_kd", kills );
}
else
{
winEvent->SetFloat( "t_kd", kills / deaths );
}
winEvent->SetInt( "t_objectives_done", CCS_GameStats.GetTeamStats(teamIndex)[CSSTAT_OBJECTIVES_COMPLETED] );
winEvent->SetInt( "t_money_earned", CCS_GameStats.GetTeamStats(teamIndex)[CSSTAT_MONEY_EARNED] );
break;
case TEAM_CT:
winEvent->SetInt( "ct_score", team->GetScore() );
if(deaths == 0)
{
winEvent->SetFloat( "ct_kd", kills );
}
else
{
winEvent->SetFloat( "ct_kd", kills / deaths );
}
winEvent->SetInt( "ct_objectives_done", CCS_GameStats.GetTeamStats(teamIndex)[CSSTAT_OBJECTIVES_COMPLETED] );
winEvent->SetInt( "ct_money_earned", CCS_GameStats.GetTeamStats(teamIndex)[CSSTAT_MONEY_EARNED] );
break;
default:
Assert( false );
break;
}
}
}
gameeventmanager->FireEvent( winEvent );
}
BaseClass::GoToIntermission();
// set all players to FL_FROZEN
for ( int i = 1; i <= MAX_PLAYERS; i++ )
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
if ( pPlayer )
{
pPlayer->AddFlag( FL_FROZEN );
}
}
// freeze players while in intermission
m_bFreezePeriod = true;
}
int PlayerScoreInfoSort( const playerscore_t *p1, const playerscore_t *p2 )
{
// check frags
if ( p1->iScore > p2->iScore )
return -1;
if ( p2->iScore > p1->iScore )
return 1;
// check index
if ( p1->iPlayerIndex < p2->iPlayerIndex )
return -1;
return 1;
}
#if defined (_DEBUG)
void TestRoundWinpanel( void )
{
IGameEvent *event = gameeventmanager->CreateEvent( "round_end" );
event->SetInt( "winner", TEAM_TERRORIST );
if ( event )
{
gameeventmanager->FireEvent( event );
}
IGameEvent *event2 = gameeventmanager->CreateEvent( "player_death" );
if ( event2 )
{
CCSPlayer *pPlayer = ToCSPlayer( UTIL_PlayerByIndex(1) );
// pCappingPlayers is a null terminated list of player indeces
event2->SetInt("userid", pPlayer->GetUserID() );
event2->SetInt("attacker", pPlayer->GetUserID() );
event2->SetString("weapon", "Bare Hands" );
event2->SetInt("headshot", 1 );
event2->SetInt( "revenge", 1 );
gameeventmanager->FireEvent( event2 );
}
IGameEvent *winEvent = gameeventmanager->CreateEvent( "cs_win_panel_round" );
if ( winEvent )
{
if ( 1 )
{
if ( 0 /*team == m_iTimerWinTeam */)
{
// timer expired, defenders win
// show total time that was defended
winEvent->SetBool( "show_timer_defend", true );
winEvent->SetInt( "timer_time", 0 /*m_pRoundTimer->GetTimerMaxLength() */);
}
else
{
// attackers win
// show time it took for them to win
winEvent->SetBool( "show_timer_attack", true );
int iTimeElapsed = 90; //m_pRoundTimer->GetTimerMaxLength() - (int)m_pRoundTimer->GetTimeRemaining();
winEvent->SetInt( "timer_time", iTimeElapsed );
}
}
else
{
winEvent->SetBool( "show_timer_attack", false );
winEvent->SetBool( "show_timer_defend", false );
}
int iLastEvent = Terrorists_Win;
winEvent->SetInt( "final_event", iLastEvent );
// Set the fun fact data in the event
winEvent->SetString( "funfact_token", "#funfact_first_blood" );
winEvent->SetInt( "funfact_player", 1 );
winEvent->SetInt( "funfact_data1", 20 );
winEvent->SetInt( "funfact_data2", 31 );
winEvent->SetInt( "funfact_data3", 45 );
gameeventmanager->FireEvent( winEvent );
}
}
ConCommand test_round_winpanel( "test_round_winpanel", TestRoundWinpanel, "", FCVAR_DEVELOPMENTONLY | FCVAR_CHEAT );
void TestMatchWinpanel( void )
{
IGameEvent *event = gameeventmanager->CreateEvent( "round_end" );
event->SetInt( "winner", TEAM_TERRORIST );
if ( event )
{
gameeventmanager->FireEvent( event );
}
IGameEvent *winEvent = gameeventmanager->CreateEvent( "cs_win_panel_match" );
if ( winEvent )
{
winEvent->SetInt( "t_score", 4 );
winEvent->SetInt( "ct_score", 1 );
winEvent->SetFloat( "t_kd", 1.8f );
winEvent->SetFloat( "ct_kd", 0.4f );
winEvent->SetInt( "t_objectives_done", 5 );
winEvent->SetInt( "ct_objectives_done", 2 );
winEvent->SetInt( "t_money_earned", 30000 );
winEvent->SetInt( "ct_money_earned", 19999 );
gameeventmanager->FireEvent( winEvent );
}
}
ConCommand test_match_winpanel( "test_match_winpanel", TestMatchWinpanel, "", FCVAR_DEVELOPMENTONLY | FCVAR_CHEAT );
void TestFreezePanel( void )
{
IGameEvent *event = gameeventmanager->CreateEvent( "freezecam_started" );
if ( event )
{
gameeventmanager->FireEvent( event );
}
IGameEvent *winEvent = gameeventmanager->CreateEvent( "show_freezepanel" );
if ( winEvent )
{
winEvent->SetInt( "killer", 1 );
gameeventmanager->FireEvent( winEvent );
}
}
ConCommand test_freezepanel( "test_freezepanel", TestFreezePanel, "", FCVAR_DEVELOPMENTONLY | FCVAR_CHEAT );
#endif // _DEBUG
static void PrintToConsole( CBasePlayer *player, const char *text )
{
if ( player )
{
ClientPrint( player, HUD_PRINTCONSOLE, text );
}
else
{
Msg( "%s", text );
}
}
void CCSGameRules::DumpTimers( void ) const
{
extern ConVar bot_join_delay;
CBasePlayer *player = UTIL_GetCommandClient();
CFmtStr str;
PrintToConsole( player, str.sprintf( "Timers and related info at %f:\n", gpGlobals->curtime ) );
PrintToConsole( player, str.sprintf( "m_bCompleteReset: %d\n", m_bCompleteReset ) );
PrintToConsole( player, str.sprintf( "m_iTotalRoundsPlayed: %d\n", m_iTotalRoundsPlayed ) );
PrintToConsole( player, str.sprintf( "m_iRoundTime: %d\n", m_iRoundTime.Get() ) );
PrintToConsole( player, str.sprintf( "m_iRoundWinStatus: %d\n", m_iRoundWinStatus ) );
PrintToConsole( player, str.sprintf( "first connected: %d\n", m_bFirstConnected ) );
PrintToConsole( player, str.sprintf( "intermission end time: %f\n", m_flIntermissionEndTime ) );
PrintToConsole( player, str.sprintf( "freeze period: %d\n", m_bFreezePeriod.Get() ) );
PrintToConsole( player, str.sprintf( "round restart time: %f\n", m_flRestartRoundTime ) );
PrintToConsole( player, str.sprintf( "game start time: %f\n", m_flGameStartTime.Get() ) );
PrintToConsole( player, str.sprintf( "m_fRoundStartTime: %f\n", m_fRoundStartTime.Get() ) );
PrintToConsole( player, str.sprintf( "freeze time: %d\n", m_iFreezeTime ) );
PrintToConsole( player, str.sprintf( "next think: %f\n", m_tmNextPeriodicThink ) );
PrintToConsole( player, str.sprintf( "fraglimit: %d\n", fraglimit.GetInt() ) );
PrintToConsole( player, str.sprintf( "mp_maxrounds: %d\n", mp_maxrounds.GetInt() ) );
PrintToConsole( player, str.sprintf( "mp_winlimit: %d\n", mp_winlimit.GetInt() ) );
PrintToConsole( player, str.sprintf( "bot_quota: %d\n", cv_bot_quota.GetInt() ) );
PrintToConsole( player, str.sprintf( "bot_quota_mode: %s\n", cv_bot_quota_mode.GetString() ) );
PrintToConsole( player, str.sprintf( "bot_join_after_player: %d\n", cv_bot_join_after_player.GetInt() ) );
PrintToConsole( player, str.sprintf( "bot_join_delay: %d\n", bot_join_delay.GetInt() ) );
PrintToConsole( player, str.sprintf( "nextlevel: %s\n", nextlevel.GetString() ) );
int humansInGame = UTIL_HumansInGame( true );
int botsInGame = UTIL_BotsInGame();
PrintToConsole( player, str.sprintf( "%d humans and %d bots in game\n", humansInGame, botsInGame ) );
PrintToConsole( player, str.sprintf( "num CTs (spawnable): %d (%d)\n", m_iNumCT, m_iNumSpawnableCT ) );
PrintToConsole( player, str.sprintf( "num Ts (spawnable): %d (%d)\n", m_iNumTerrorist, m_iNumSpawnableTerrorist ) );
if ( g_fGameOver )
{
PrintToConsole( player, str.sprintf( "Game is over!\n" ) );
}
PrintToConsole( player, str.sprintf( "\n" ) );
}
CON_COMMAND( mp_dump_timers, "Prints round timers to the console for debugging" )
{
if ( !UTIL_IsCommandIssuedByServerAdmin() )
return;
if ( CSGameRules() )
{
CSGameRules()->DumpTimers();
}
}
// living players on the given team need to be marked as not receiving any money
// next round.
void CCSGameRules::MarkLivingPlayersOnTeamAsNotReceivingMoneyNextRound(int team)
{
int playerNum;
for (playerNum = 1; playerNum <= gpGlobals->maxClients; ++playerNum)
{
CCSPlayer *player = (CCSPlayer *)UTIL_PlayerByIndex(playerNum);
if (player == NULL)
{
continue;
}
if ((player->GetTeamNumber() == team) && (player->IsAlive()))
{
player->MarkAsNotReceivingMoneyNextRound();
}
}
}
void CCSGameRules::CheckLevelInitialized( void )
{
if ( !m_bLevelInitialized )
{
// Count the number of spawn points for each team
// This determines the maximum number of players allowed on each
CBaseEntity* ent = NULL;
m_iSpawnPointCount_Terrorist = 0;
m_iSpawnPointCount_CT = 0;
while ( ( ent = gEntList.FindEntityByClassname( ent, "info_player_terrorist" ) ) != NULL )
{
if ( IsSpawnPointValid( ent, NULL ) )
{
m_iSpawnPointCount_Terrorist++;
}
else
{
Warning("Invalid terrorist spawnpoint at (%.1f,%.1f,%.1f)\n",
ent->GetAbsOrigin()[0],ent->GetAbsOrigin()[2],ent->GetAbsOrigin()[2] );
}
}
while ( ( ent = gEntList.FindEntityByClassname( ent, "info_player_counterterrorist" ) ) != NULL )
{
if ( IsSpawnPointValid( ent, NULL ) )
{
m_iSpawnPointCount_CT++;
}
else
{
Warning("Invalid counterterrorist spawnpoint at (%.1f,%.1f,%.1f)\n",
ent->GetAbsOrigin()[0],ent->GetAbsOrigin()[2],ent->GetAbsOrigin()[2] );
}
}
// Is this a logo map?
if ( gEntList.FindEntityByClassname( NULL, "info_player_logo" ) )
m_bLogoMap = true;
m_bLevelInitialized = true;
}
}
void CCSGameRules::ShowSpawnPoints( void )
{
CBaseEntity* ent = NULL;
while ( ( ent = gEntList.FindEntityByClassname( ent, "info_player_terrorist" ) ) != NULL )
{
if ( IsSpawnPointValid( ent, NULL ) )
{
NDebugOverlay::Box( ent->GetAbsOrigin(), VEC_HULL_MIN, VEC_HULL_MAX, 0, 255, 0, 200, 600 );
}
else
{
NDebugOverlay::Box( ent->GetAbsOrigin(), VEC_HULL_MIN, VEC_HULL_MAX, 255, 0, 0, 200, 600);
}
}
while ( ( ent = gEntList.FindEntityByClassname( ent, "info_player_counterterrorist" ) ) != NULL )
{
if ( IsSpawnPointValid( ent, NULL ) )
{
NDebugOverlay::Box( ent->GetAbsOrigin(), VEC_HULL_MIN, VEC_HULL_MAX, 0, 255, 0, 200, 600 );
}
else
{
NDebugOverlay::Box( ent->GetAbsOrigin(), VEC_HULL_MIN, VEC_HULL_MAX, 255, 0, 0, 200, 600 );
}
}
}
void CCSGameRules::CheckRestartRound( void )
{
// Restart the game if specified by the server
int iRestartDelay = mp_restartgame.GetInt();
if ( iRestartDelay > 0 )
{
if ( iRestartDelay > 60 )
iRestartDelay = 60;
// log the restart
UTIL_LogPrintf( "World triggered \"Restart_Round_(%i_%s)\"\n", iRestartDelay, iRestartDelay == 1 ? "second" : "seconds" );
UTIL_LogPrintf( "Team \"CT\" scored \"%i\" with \"%i\" players\n", m_iNumCTWins, m_iNumCT );
UTIL_LogPrintf( "Team \"TERRORIST\" scored \"%i\" with \"%i\" players\n", m_iNumTerroristWins, m_iNumTerrorist );
// let the players know
char strRestartDelay[64];
Q_snprintf( strRestartDelay, sizeof( strRestartDelay ), "%d", iRestartDelay );
UTIL_ClientPrintAll( HUD_PRINTCENTER, "#Game_will_restart_in", strRestartDelay, iRestartDelay == 1 ? "SECOND" : "SECONDS" );
UTIL_ClientPrintAll( HUD_PRINTCONSOLE, "#Game_will_restart_in", strRestartDelay, iRestartDelay == 1 ? "SECOND" : "SECONDS" );
m_flRestartRoundTime = gpGlobals->curtime + iRestartDelay;
m_bCompleteReset = true;
mp_restartgame.SetValue( 0 );
}
}
class SetHumanTeamFunctor
{
public:
SetHumanTeamFunctor( int targetTeam )
{
m_targetTeam = targetTeam;
m_sourceTeam = ( m_targetTeam == TEAM_CT ) ? TEAM_TERRORIST : TEAM_CT;
m_traitors.MakeReliable();
m_loyalists.MakeReliable();
m_loyalists.AddAllPlayers();
}
bool operator()( CBasePlayer *basePlayer )
{
CCSPlayer *player = ToCSPlayer( basePlayer );
if ( !player )
return true;
if ( player->IsBot() )
return true;
if ( player->GetTeamNumber() != m_sourceTeam )
return true;
if ( player->State_Get() == STATE_PICKINGCLASS )
return true;
if ( CSGameRules()->TeamFull( m_targetTeam ) )
return false;
if ( CSGameRules()->TeamStacked( m_targetTeam, m_sourceTeam ) )
return false;
player->SwitchTeam( m_targetTeam );
m_traitors.AddRecipient( player );
m_loyalists.RemoveRecipient( player );
return true;
}
void SendNotice( void )
{
if ( m_traitors.GetRecipientCount() > 0 )
{
UTIL_ClientPrintFilter( m_traitors, HUD_PRINTCENTER, "#Player_Balanced" );
UTIL_ClientPrintFilter( m_loyalists, HUD_PRINTCENTER, "#Teams_Balanced" );
}
}
private:
int m_targetTeam;
int m_sourceTeam;
CRecipientFilter m_traitors;
CRecipientFilter m_loyalists;
};
void CCSGameRules::MoveHumansToHumanTeam( void )
{
int targetTeam = GetHumanTeam();
if ( targetTeam != TEAM_TERRORIST && targetTeam != TEAM_CT )
return;
SetHumanTeamFunctor setTeam( targetTeam );
ForEachPlayer( setTeam );
setTeam.SendNotice();
}
void CCSGameRules::BalanceTeams( void )
{
int iTeamToSwap = TEAM_UNASSIGNED;
int iNumToSwap;
if (m_iMapHasVIPSafetyZone == 1) // The ratio for teams is different for Assasination maps
{
int iDesiredNumCT, iDesiredNumTerrorist;
if ( (m_iNumCT + m_iNumTerrorist)%2 != 0) // uneven number of players
iDesiredNumCT = (int)((m_iNumCT + m_iNumTerrorist) * 0.55) + 1;
else
iDesiredNumCT = (int)((m_iNumCT + m_iNumTerrorist)/2);
iDesiredNumTerrorist = (m_iNumCT + m_iNumTerrorist) - iDesiredNumCT;
if ( m_iNumCT < iDesiredNumCT )
{
iTeamToSwap = TEAM_TERRORIST;
iNumToSwap = iDesiredNumCT - m_iNumCT;
}
else if ( m_iNumTerrorist < iDesiredNumTerrorist )
{
iTeamToSwap = TEAM_CT;
iNumToSwap = iDesiredNumTerrorist - m_iNumTerrorist;
}
else
return;
}
else
{
if (m_iNumCT > m_iNumTerrorist)
{
iTeamToSwap = TEAM_CT;
iNumToSwap = (m_iNumCT - m_iNumTerrorist)/2;
}
else if (m_iNumTerrorist > m_iNumCT)
{
iTeamToSwap = TEAM_TERRORIST;
iNumToSwap = (m_iNumTerrorist - m_iNumCT)/2;
}
else
{
return; // Teams are even.. Get out of here.
}
}
if (iNumToSwap > 3) // Don't swap more than 3 players at a time.. This is a naive method of avoiding infinite loops.
iNumToSwap = 3;
int iTragetTeam = TEAM_UNASSIGNED;
if ( iTeamToSwap == TEAM_CT )
{
iTragetTeam = TEAM_TERRORIST;
}
else if ( iTeamToSwap == TEAM_TERRORIST )
{
iTragetTeam = TEAM_CT;
}
else
{
// no valid team to swap
return;
}
CRecipientFilter traitors;
CRecipientFilter loyalists;
traitors.MakeReliable();
loyalists.MakeReliable();
loyalists.AddAllPlayers();
for (int i = 0; i < iNumToSwap; i++)
{
// last person to join the server
int iHighestUserID = -1;
CCSPlayer *pPlayerToSwap = NULL;
// check if target team is full, exit if so
if ( TeamFull(iTragetTeam) )
break;
// search for player with highest UserID = most recently joined to switch over
for ( int j = 1; j <= gpGlobals->maxClients; j++ )
{
CCSPlayer *pPlayer = (CCSPlayer *)UTIL_PlayerByIndex( j );
if ( !pPlayer )
continue;
CCSBot *bot = dynamic_cast< CCSBot * >(pPlayer);
if ( bot )
continue; // don't swap bots - the bot system will handle that
if ( pPlayer &&
( m_pVIP != pPlayer ) &&
( pPlayer->GetTeamNumber() == iTeamToSwap ) &&
( engine->GetPlayerUserId( pPlayer->edict() ) > iHighestUserID ) &&
( pPlayer->State_Get() != STATE_PICKINGCLASS ) )
{
iHighestUserID = engine->GetPlayerUserId( pPlayer->edict() );
pPlayerToSwap = pPlayer;
}
}
if ( pPlayerToSwap != NULL )
{
traitors.AddRecipient( pPlayerToSwap );
loyalists.RemoveRecipient( pPlayerToSwap );
pPlayerToSwap->SwitchTeam( iTragetTeam );
}
}
if ( traitors.GetRecipientCount() > 0 )
{
UTIL_ClientPrintFilter( traitors, HUD_PRINTCENTER, "#Player_Balanced" );
UTIL_ClientPrintFilter( loyalists, HUD_PRINTCENTER, "#Teams_Balanced" );
}
}
bool CCSGameRules::TeamFull( int team_id )
{
CheckLevelInitialized();
switch ( team_id )
{
case TEAM_TERRORIST:
return m_iNumTerrorist >= m_iSpawnPointCount_Terrorist;
case TEAM_CT:
return m_iNumCT >= m_iSpawnPointCount_CT;
}
return false;
}
int CCSGameRules::GetHumanTeam()
{
if ( FStrEq( "CT", mp_humanteam.GetString() ) )
{
return TEAM_CT;
}
else if ( FStrEq( "T", mp_humanteam.GetString() ) )
{
return TEAM_TERRORIST;
}
return TEAM_UNASSIGNED;
}
int CCSGameRules::SelectDefaultTeam( bool ignoreBots /*= false*/ )
{
if ( ignoreBots && ( FStrEq( cv_bot_join_team.GetString(), "T" ) || FStrEq( cv_bot_join_team.GetString(), "CT" ) ) )
{
ignoreBots = false; // don't ignore bots when they can't switch teams
}
if ( ignoreBots && !mp_autoteambalance.GetBool() )
{
ignoreBots = false; // don't ignore bots when they can't switch teams
}
int team = TEAM_UNASSIGNED;
int numTerrorists = m_iNumTerrorist;
int numCTs = m_iNumCT;
if ( ignoreBots )
{
numTerrorists = UTIL_HumansOnTeam( TEAM_TERRORIST );
numCTs = UTIL_HumansOnTeam( TEAM_CT );
}
// Choose the team that's lacking players
if ( numTerrorists < numCTs )
{
team = TEAM_TERRORIST;
}
else if ( numTerrorists > numCTs )
{
team = TEAM_CT;
}
// Choose the team that's losing
else if ( m_iNumTerroristWins < m_iNumCTWins )
{
team = TEAM_TERRORIST;
}
else if ( m_iNumCTWins < m_iNumTerroristWins )
{
team = TEAM_CT;
}
else
{
// Teams and scores are equal, pick a random team
if ( random->RandomInt( 0, 1 ) == 0 )
{
team = TEAM_CT;
}
else
{
team = TEAM_TERRORIST;
}
}
if ( TeamFull( team ) )
{
// Pick the opposite team
if ( team == TEAM_TERRORIST )
{
team = TEAM_CT;
}
else
{
team = TEAM_TERRORIST;
}
// No choices left
if ( TeamFull( team ) )
return TEAM_UNASSIGNED;
}
return team;
}
//checks to see if the desired team is stacked, returns true if it is
bool CCSGameRules::TeamStacked( int newTeam_id, int curTeam_id )
{
//players are allowed to change to their own team
if(newTeam_id == curTeam_id)
return false;
// if mp_limitteams is 0, don't check
if ( mp_limitteams.GetInt() == 0 )
return false;
switch ( newTeam_id )
{
case TEAM_TERRORIST:
if(curTeam_id != TEAM_UNASSIGNED && curTeam_id != TEAM_SPECTATOR)
{
if((m_iNumTerrorist + 1) > (m_iNumCT + mp_limitteams.GetInt() - 1))
return true;
else
return false;
}
else
{
if((m_iNumTerrorist + 1) > (m_iNumCT + mp_limitteams.GetInt()))
return true;
else
return false;
}
break;
case TEAM_CT:
if(curTeam_id != TEAM_UNASSIGNED && curTeam_id != TEAM_SPECTATOR)
{
if((m_iNumCT + 1) > (m_iNumTerrorist + mp_limitteams.GetInt() - 1))
return true;
else
return false;
}
else
{
if((m_iNumCT + 1) > (m_iNumTerrorist + mp_limitteams.GetInt()))
return true;
else
return false;
}
break;
}
return false;
}
//=========================================================
//=========================================================
bool CCSGameRules::FPlayerCanRespawn( CBasePlayer *pBasePlayer )
{
CCSPlayer *pPlayer = ToCSPlayer( pBasePlayer );
if ( !pPlayer )
Error( "FPlayerCanRespawn: pPlayer=0" );
// Player cannot respawn twice in a round
if ( pPlayer->m_iNumSpawns > 0 && m_bFirstConnected )
return false;
// If they're dead after the map has ended, and it's about to start the next round,
// wait for the round restart to respawn them.
if ( gpGlobals->curtime < m_flRestartRoundTime )
return false;
// Only valid team members can spawn
if ( pPlayer->GetTeamNumber() != TEAM_CT && pPlayer->GetTeamNumber() != TEAM_TERRORIST )
return false;
// Only players with a valid class can spawn
if ( pPlayer->GetClass() == CS_CLASS_NONE )
return false;
// Player cannot respawn until next round if more than 20 seconds in
// Tabulate the number of players on each team.
m_iNumCT = GetGlobalTeam( TEAM_CT )->GetNumPlayers();
m_iNumTerrorist = GetGlobalTeam( TEAM_TERRORIST )->GetNumPlayers();
if ( m_iNumTerrorist > 0 && m_iNumCT > 0 )
{
if ( gpGlobals->curtime > (m_fRoundStartTime + 20) )
{
//If this player just connected and fadetoblack is on, then maybe
//the server admin doesn't want him peeking around.
color32_s clr = {0,0,0,255};
if ( mp_fadetoblack.GetBool() )
{
UTIL_ScreenFade( pPlayer, clr, 3, 3, FFADE_OUT | FFADE_STAYOUT );
}
return false;
}
}
// Player cannot respawn while in the Choose Appearance menu
//if ( pPlayer->m_iMenu == Menu_ChooseAppearance )
// return false;
return true;
}
void CCSGameRules::TerminateRound(float tmDelay, int iReason )
{
variant_t emptyVariant;
int iWinnerTeam = WINNER_NONE;
const char *text = "UNKNOWN";
// UTIL_ClientPrintAll( HUD_PRINTCENTER, sentence );
switch ( iReason )
{
// Terror wins:
case Target_Bombed:
text = "#Target_Bombed";
iWinnerTeam = WINNER_TER;
break;
case VIP_Assassinated:
text = "#VIP_Assassinated";
iWinnerTeam = WINNER_TER;
break;
case Terrorists_Escaped:
text = "#Terrorists_Escaped";
iWinnerTeam = WINNER_TER;
break;
case Terrorists_Win:
text = "#Terrorists_Win";
iWinnerTeam = WINNER_TER;
break;
case Hostages_Not_Rescued:
text = "#Hostages_Not_Rescued";
iWinnerTeam = WINNER_TER;
break;
case VIP_Not_Escaped:
text = "#VIP_Not_Escaped";
iWinnerTeam = WINNER_TER;
break;
// CT wins:
case VIP_Escaped:
text = "#VIP_Escaped";
iWinnerTeam = WINNER_CT;
break;
case CTs_PreventEscape:
text = "#CTs_PreventEscape";
iWinnerTeam = WINNER_CT;
break;
case Escaping_Terrorists_Neutralized:
text = "#Escaping_Terrorists_Neutralized";
iWinnerTeam = WINNER_CT;
break;
case Bomb_Defused:
text = "#Bomb_Defused";
iWinnerTeam = WINNER_CT;
break;
case CTs_Win:
text = "#CTs_Win";
iWinnerTeam = WINNER_CT;
break;
case All_Hostages_Rescued:
text = "#All_Hostages_Rescued";
iWinnerTeam = WINNER_CT;
break;
case Target_Saved:
text = "#Target_Saved";
iWinnerTeam = WINNER_CT;
break;
case Terrorists_Not_Escaped:
text = "#Terrorists_Not_Escaped";
iWinnerTeam = WINNER_CT;
break;
// no winners:
case Game_Commencing:
text = "#Game_Commencing";
iWinnerTeam = WINNER_DRAW;
break;
case Round_Draw:
text = "#Round_Draw";
iWinnerTeam = WINNER_DRAW;
break;
default:
DevMsg("TerminateRound: unknown round end ID %i\n", iReason );
break;
}
m_iRoundWinStatus = iWinnerTeam;
m_flRestartRoundTime = gpGlobals->curtime + tmDelay;
if ( iWinnerTeam == WINNER_CT )
{
for( int i=0;i<g_Hostages.Count();i++ )
g_Hostages[i]->AcceptInput( "CTsWin", NULL, NULL, emptyVariant, 0 );
}
else if ( iWinnerTeam == WINNER_TER )
{
for( int i=0;i<g_Hostages.Count();i++ )
g_Hostages[i]->AcceptInput( "TerroristsWin", NULL, NULL, emptyVariant, 0 );
}
else
{
Assert( iWinnerTeam == WINNER_NONE || iWinnerTeam == WINNER_DRAW );
}
//=============================================================================
// HPE_BEGIN:
//=============================================================================
// [tj] Check for any non-player-specific achievements.
ProcessEndOfRoundAchievements(iWinnerTeam, iReason);
if( iReason != Game_Commencing )
{
// [pfreese] Setup and send win panel event (primarily funfact data)
FunFact funfact;
funfact.szLocalizationToken = "";
funfact.iPlayer = 0;
funfact.iData1 = 0;
funfact.iData2 = 0;
funfact.iData3 = 0;
m_pFunFactManager->GetRoundEndFunFact( iWinnerTeam, iReason, funfact);
//Send all the info needed for the win panel
IGameEvent *winEvent = gameeventmanager->CreateEvent( "cs_win_panel_round" );
if ( winEvent )
{
// determine what categories to send
if ( GetRoundRemainingTime() <= 0 )
{
// timer expired, defenders win
// show total time that was defended
winEvent->SetBool( "show_timer_defend", true );
winEvent->SetInt( "timer_time", m_iRoundTime );
}
else
{
// attackers win
// show time it took for them to win
winEvent->SetBool( "show_timer_attack", true );
int iTimeElapsed = m_iRoundTime - GetRoundRemainingTime();
winEvent->SetInt( "timer_time", iTimeElapsed );
}
winEvent->SetInt( "final_event", iReason );
// Set the fun fact data in the event
winEvent->SetString( "funfact_token", funfact.szLocalizationToken);
winEvent->SetInt( "funfact_player", funfact.iPlayer );
winEvent->SetInt( "funfact_data1", funfact.iData1 );
winEvent->SetInt( "funfact_data2", funfact.iData2 );
winEvent->SetInt( "funfact_data3", funfact.iData3 );
gameeventmanager->FireEvent( winEvent );
}
}
// [tj] Inform players that the round is over
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CCSPlayer *pPlayer = (CCSPlayer*) UTIL_PlayerByIndex( i );
if(pPlayer)
{
pPlayer->OnRoundEnd(iWinnerTeam, iReason);
}
}
//=============================================================================
// HPE_END
//=============================================================================
IGameEvent * event = gameeventmanager->CreateEvent( "round_end" );
if ( event )
{
event->SetInt( "winner", iWinnerTeam );
event->SetInt( "reason", iReason );
event->SetString( "message", text );
event->SetInt( "priority", 6 ); // HLTV event priority, not transmitted
gameeventmanager->FireEvent( event );
}
if ( GetMapRemainingTime() == 0.0f )
{
UTIL_LogPrintf("World triggered \"Intermission_Time_Limit\"\n");
GoToIntermission();
}
}
//=============================================================================
// HPE_BEGIN:
//=============================================================================
// Helper to determine if all players on a team are playing for the same clan
static bool IsClanTeam( CTeam *pTeam )
{
uint32 iTeamClan = 0;
for ( int iPlayer = 0; iPlayer < pTeam->GetNumPlayers(); iPlayer++ )
{
CBasePlayer *pPlayer = pTeam->GetPlayer( iPlayer );
if ( !pPlayer )
return false;
const char *pClanID = engine->GetClientConVarValue( pPlayer->entindex(), "cl_clanid" );
uint32 iPlayerClan = atoi( pClanID );
if ( iPlayer == 0 )
{
// Initialize the team clan
iTeamClan = iPlayerClan;
}
else
{
if ( iPlayerClan != iTeamClan || iPlayerClan == 0 )
return false;
}
}
return iTeamClan != 0;
}
// [tj] This is where we check non-player-specific that occur at the end of the round
void CCSGameRules::ProcessEndOfRoundAchievements(int iWinnerTeam, int iReason)
{
if (iWinnerTeam == WINNER_CT || iWinnerTeam == WINNER_TER)
{
int losingTeamId = (iWinnerTeam == TEAM_CT) ? TEAM_TERRORIST : TEAM_CT;
CTeam* losingTeam = GetGlobalTeam(losingTeamId);
//Check for players we should ignore when checking team size.
int ignoreCount = 0;
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CCSPlayer* pPlayer = (CCSPlayer*)UTIL_PlayerByIndex( i );
if (pPlayer)
{
int teamNum = pPlayer->GetTeamNumber();
if ( teamNum == losingTeamId )
{
if (pPlayer->WasNotKilledNaturally())
{
ignoreCount++;
}
}
}
}
// [tj] Check extermination with no losses achievement
if ( ( ( iReason == CTs_Win && m_bNoCTsKilled ) || ( iReason == Terrorists_Win && m_bNoTerroristsKilled ) )
&& losingTeam && losingTeam->GetNumPlayers() - ignoreCount >= AchievementConsts::DefaultMinOpponentsForAchievement)
{
CTeam *pTeam = GetGlobalTeam( iWinnerTeam );
for ( int iPlayer=0; iPlayer < pTeam->GetNumPlayers(); iPlayer++ )
{
CCSPlayer *pPlayer = ToCSPlayer( pTeam->GetPlayer( iPlayer ) );
Assert( pPlayer );
if ( !pPlayer )
continue;
pPlayer->AwardAchievement(CSLosslessExtermination);
}
}
// [tj] Check flawless victory achievement - currently requiring extermination
if (((iReason == CTs_Win && m_bNoCTsDamaged) || (iReason == Terrorists_Win && m_bNoTerroristsDamaged))
&& losingTeam && losingTeam->GetNumPlayers() - ignoreCount >= AchievementConsts::DefaultMinOpponentsForAchievement)
{
CTeam *pTeam = GetGlobalTeam( iWinnerTeam );
for ( int iPlayer=0; iPlayer < pTeam->GetNumPlayers(); iPlayer++ )
{
CCSPlayer *pPlayer = ToCSPlayer( pTeam->GetPlayer( iPlayer ) );
Assert( pPlayer );
if ( !pPlayer )
continue;
pPlayer->AwardAchievement(CSFlawlessVictory);
}
}
// [tj] Check bloodless victory achievement
if (((iWinnerTeam == TEAM_TERRORIST && m_bNoCTsKilled) || (iWinnerTeam == Terrorists_Win && m_bNoTerroristsKilled))
&& losingTeam && losingTeam->GetNumPlayers() >= AchievementConsts::DefaultMinOpponentsForAchievement)
{
CTeam *pTeam = GetGlobalTeam( iWinnerTeam );
for ( int iPlayer=0; iPlayer < pTeam->GetNumPlayers(); iPlayer++ )
{
CCSPlayer *pPlayer = ToCSPlayer( pTeam->GetPlayer( iPlayer ) );
Assert( pPlayer );
if ( !pPlayer )
continue;
pPlayer->AwardAchievement(CSBloodlessVictory);
}
}
// Check the clan match achievement
CTeam *pWinningTeam = GetGlobalTeam( iWinnerTeam );
if ( pWinningTeam && pWinningTeam->GetNumPlayers() >= AchievementConsts::DefaultMinOpponentsForAchievement &&
losingTeam && losingTeam->GetNumPlayers() - ignoreCount >= AchievementConsts::DefaultMinOpponentsForAchievement &&
IsClanTeam( pWinningTeam ) && IsClanTeam( losingTeam ) )
{
for ( int iPlayer=0; iPlayer < pWinningTeam->GetNumPlayers(); iPlayer++ )
{
CCSPlayer *pPlayer = ToCSPlayer( pWinningTeam->GetPlayer( iPlayer ) );
if ( !pPlayer )
continue;
pPlayer->AwardAchievement( CSWinClanMatch );
}
}
}
}
//[tj] Counts the number of players in each category in the struct (dead, alive, etc...)
void CCSGameRules::GetPlayerCounts(TeamPlayerCounts teamCounts[TEAM_MAXCOUNT])
{
memset(teamCounts, 0, sizeof(TeamPlayerCounts) * TEAM_MAXCOUNT);
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CCSPlayer* pPlayer = (CCSPlayer*)UTIL_PlayerByIndex( i );
if (pPlayer)
{
int iTeam = pPlayer->GetTeamNumber();
if (iTeam >= 0 && iTeam < TEAM_MAXCOUNT)
{
++teamCounts[iTeam].totalPlayers;
if (pPlayer->IsAlive())
{
++teamCounts[iTeam].totalAlivePlayers;
}
else
{
++teamCounts[iTeam].totalDeadPlayers;
//If the player has joined a team bit isn't in the game yet
if (pPlayer->State_Get() == STATE_PICKINGCLASS)
{
++teamCounts[iTeam].unenteredPlayers;
}
else if (pPlayer->WasNotKilledNaturally())
{
++teamCounts[iTeam].suicidedPlayers;
}
else
{
++teamCounts[iTeam].killedPlayers;
}
}
}
}
}
}
//=============================================================================
// HPE_END
//=============================================================================
void CCSGameRules::UpdateTeamScores()
{
CTeam *pTerrorists = GetGlobalTeam( TEAM_TERRORIST );
CTeam *pCTs = GetGlobalTeam( TEAM_CT );
Assert( pTerrorists && pCTs );
if( pTerrorists )
pTerrorists->SetScore( m_iNumTerroristWins );
if( pCTs )
pCTs->SetScore( m_iNumCTWins );
}
void CCSGameRules::CheckMapConditions()
{
// Check to see if this map has a bomb target in it
if ( gEntList.FindEntityByClassname( NULL, "func_bomb_target" ) )
{
m_bMapHasBombTarget = true;
m_bMapHasBombZone = true;
}
else if ( gEntList.FindEntityByClassname( NULL, "info_bomb_target" ) )
{
m_bMapHasBombTarget = true;
m_bMapHasBombZone = false;
}
else
{
m_bMapHasBombTarget = false;
m_bMapHasBombZone = false;
}
// See if the map has func_buyzone entities
// Used by CBasePlayer::HandleSignals() to support maps without these entities
if ( gEntList.FindEntityByClassname( NULL, "func_buyzone" ) )
{
m_bMapHasBuyZone = true;
}
else
{
m_bMapHasBuyZone = false;
}
// Check to see if this map has hostage rescue zones
if ( gEntList.FindEntityByClassname( NULL, "func_hostage_rescue" ) )
{
m_bMapHasRescueZone = true;
}
else
{
m_bMapHasRescueZone = false;
}
// GOOSEMAN : See if this map has func_escapezone entities
if ( gEntList.FindEntityByClassname( NULL, "func_escapezone" ) )
{
m_bMapHasEscapeZone = true;
}
else
{
m_bMapHasEscapeZone = false;
}
// Check to see if this map has VIP safety zones
if ( gEntList.FindEntityByClassname( NULL, "func_vip_safetyzone" ) )
{
m_iMapHasVIPSafetyZone = 1;
}
else
{
m_iMapHasVIPSafetyZone = 2;
}
}
void CCSGameRules::SwapAllPlayers()
{
// MOTODO we have to make sure that enought spaning points exits
Assert ( 0 );
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
/* CCSPlayer *pPlayer = CCSPlayer::Instance( i );
if ( pPlayer && !FNullEnt( pPlayer->edict() ) )
pPlayer->SwitchTeam(); */
}
// Swap Team victories
int iTemp;
iTemp = m_iNumCTWins;
m_iNumCTWins = m_iNumTerroristWins;
m_iNumTerroristWins = iTemp;
// Update the clients team score
UpdateTeamScores();
}
bool CS_FindInList( const char **pStrings, const char *pToFind )
{
return FindInList( pStrings, pToFind );
}
void CCSGameRules::CleanUpMap()
{
if (IsLogoMap())
return;
// 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 )
{
CWeaponCSBase *pWeapon = dynamic_cast< CWeaponCSBase* >( pCur );
// Weapons with owners don't want to be removed..
if ( pWeapon )
{
//=============================================================================
// HPE_BEGIN:
// [dwenger] Handle round restart processing for the weapon.
//=============================================================================
pWeapon->OnRoundRestart();
//=============================================================================
// HPE_END
//=============================================================================
if ( pWeapon->ShouldRemoveOnRoundRestart() )
{
UTIL_Remove( pCur );
}
}
// remove entities that has to be restored on roundrestart (breakables etc)
else if ( !CS_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();
// Now reload the map entities.
class CCSMapEntityFilter : public IMapEntityFilter
{
public:
virtual bool ShouldCreateEntity( const char *pClassname )
{
// Don't recreate the preserved entities.
if ( !CS_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.
};
CCSMapEntityFilter filter;
filter.m_iIterator = g_MapEntityRefs.Head();
// DO NOT CALL SPAWN ON info_node ENTITIES!
MapEntity_ParseAllEntities( engine->GetMapEntitiesString(), &filter, true );
}
bool CCSGameRules::IsThereABomber()
{
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CCSPlayer *pPlayer = CCSPlayer::Instance( i );
if ( pPlayer && !FNullEnt( pPlayer->edict() ) )
{
if ( pPlayer->GetTeamNumber() == TEAM_CT )
continue;
if ( pPlayer->HasC4() )
return true; //There you are.
}
}
//Didn't find a bomber.
return false;
}
void CCSGameRules::EndRound()
{
// fake a round end
CSGameRules()->TerminateRound( 0.0f, Round_Draw );
}
CBaseEntity *CCSGameRules::GetPlayerSpawnSpot( CBasePlayer *pPlayer )
{
// gat valid spwan point
CBaseEntity *pSpawnSpot = pPlayer->EntSelectSpawnPoint();
// drop down to ground
Vector GroundPos = DropToGround( pPlayer, pSpawnSpot->GetAbsOrigin(), VEC_HULL_MIN, VEC_HULL_MAX );
// Move the player to the place it said.
pPlayer->Teleport( &pSpawnSpot->GetAbsOrigin(), &pSpawnSpot->GetLocalAngles(), &vec3_origin );
pPlayer->m_Local.m_vecPunchAngle = vec3_angle;
return pSpawnSpot;
}
// checks if the spot is clear of players
bool CCSGameRules::IsSpawnPointValid( CBaseEntity *pSpot, CBasePlayer *pPlayer )
{
if ( !pSpot->IsTriggered( pPlayer ) )
{
return false;
}
Vector mins = GetViewVectors()->m_vHullMin;
Vector maxs = GetViewVectors()->m_vHullMax;
Vector vTestMins = pSpot->GetAbsOrigin() + mins;
Vector vTestMaxs = pSpot->GetAbsOrigin() + maxs;
// First test the starting origin.
return UTIL_IsSpaceEmpty( pPlayer, vTestMins, vTestMaxs );
}
bool CCSGameRules::IsThereABomb()
{
bool bBombFound = false;
/* are there any bombs, either laying around, or in someone's inventory? */
if( gEntList.FindEntityByClassname( NULL, WEAPON_C4_CLASSNAME ) != 0 )
{
bBombFound = true;
}
/* what about planted bombs!? */
else if( gEntList.FindEntityByClassname( NULL, PLANTED_C4_CLASSNAME ) != 0 )
{
bBombFound = true;
}
return bBombFound;
}
void CCSGameRules::HostageTouched()
{
if( gpGlobals->curtime > m_flNextHostageAnnouncement && m_iRoundWinStatus == WINNER_NONE )
{
//BroadcastSound( "Event.HostageTouched" );
m_flNextHostageAnnouncement = gpGlobals->curtime + 60.0;
}
}
void CCSGameRules::CreateStandardEntities()
{
// Create the player resource
g_pPlayerResource = (CPlayerResource*)CBaseEntity::Create( "cs_player_manager", vec3_origin, vec3_angle );
// Create the entity that will send our data to the client.
#ifdef DBGFLAG_ASSERT
CBaseEntity *pEnt =
#endif
CBaseEntity::Create( "cs_gamerules", vec3_origin, vec3_angle );
Assert( pEnt );
}
#define MY_USHRT_MAX 0xffff
#define MY_UCHAR_MAX 0xff
bool DataHasChanged( void )
{
for ( int i = 0; i < CS_NUM_LEVELS; i++ )
{
if ( g_iTerroristVictories[i] != 0 || g_iCounterTVictories[i] != 0 )
return true;
}
for ( int i = 0; i < WEAPON_MAX; i++ )
{
if ( g_iWeaponPurchases[i] != 0 )
return true;
}
return false;
}
void CCSGameRules::UploadGameStats( void )
{
g_flGameStatsUpdateTime -= gpGlobals->curtime;
if ( g_flGameStatsUpdateTime > 0 )
return;
if ( IsBlackMarket() == false )
return;
if ( m_bDontUploadStats == true )
return;
if ( DataHasChanged() == true )
{
cs_gamestats_t stats;
memset( &stats, 0, sizeof(stats) );
// Header
stats.header.iVersion = CS_STATS_BLOB_VERSION;
Q_strncpy( stats.header.szGameName, "cstrike", sizeof(stats.header.szGameName) );
Q_strncpy( stats.header.szMapName, STRING( gpGlobals->mapname ), sizeof( stats.header.szMapName ) );
ConVar *hostip = cvar->FindVar( "hostip" );
if ( hostip )
{
int ip = hostip->GetInt();
stats.header.ipAddr[0] = ip >> 24;
stats.header.ipAddr[1] = ( ip >> 16 ) & MY_UCHAR_MAX;
stats.header.ipAddr[2] = ( ip >> 8 ) & MY_UCHAR_MAX;
stats.header.ipAddr[3] = ( ip ) & MY_UCHAR_MAX;
}
ConVar *hostport = cvar->FindVar( "hostip" );
if ( hostport )
{
stats.header.port = hostport->GetInt();
}
stats.header.serverid = 0;
stats.iMinutesPlayed = clamp( (short)( gpGlobals->curtime / 60 ), 0, MY_USHRT_MAX );
memcpy( stats.iTerroristVictories, g_iTerroristVictories, sizeof( g_iTerroristVictories) );
memcpy( stats.iCounterTVictories, g_iCounterTVictories, sizeof( g_iCounterTVictories) );
memcpy( stats.iBlackMarketPurchases, g_iWeaponPurchases, sizeof( g_iWeaponPurchases) );
stats.iAutoBuyPurchases = g_iAutoBuyPurchases;
stats.iReBuyPurchases = g_iReBuyPurchases;
stats.iAutoBuyM4A1Purchases = g_iAutoBuyM4A1Purchases;
stats.iAutoBuyAK47Purchases = g_iAutoBuyAK47Purchases;
stats.iAutoBuyFamasPurchases = g_iAutoBuyFamasPurchases;
stats.iAutoBuyGalilPurchases = g_iAutoBuyGalilPurchases;
stats.iAutoBuyVestHelmPurchases = g_iAutoBuyVestHelmPurchases;
stats.iAutoBuyVestPurchases = g_iAutoBuyVestPurchases;
const void *pvBlobData = ( const void * )( &stats );
unsigned int uBlobSize = sizeof( stats );
if ( gamestatsuploader )
{
gamestatsuploader->UploadGameStats(
STRING( gpGlobals->mapname ),
CS_STATS_BLOB_VERSION,
uBlobSize,
pvBlobData );
}
memset( g_iWeaponPurchases, 0, sizeof( g_iWeaponPurchases) );
memset( g_iTerroristVictories, 0, sizeof( g_iTerroristVictories) );
memset( g_iCounterTVictories, 0, sizeof( g_iTerroristVictories) );
g_iAutoBuyPurchases = 0;
g_iReBuyPurchases = 0;
g_iAutoBuyM4A1Purchases = 0;
g_iAutoBuyAK47Purchases = 0;
g_iAutoBuyFamasPurchases = 0;
g_iAutoBuyGalilPurchases = 0;
g_iAutoBuyVestHelmPurchases = 0;
g_iAutoBuyVestPurchases = 0;
}
g_flGameStatsUpdateTime = CS_GAME_STATS_UPDATE; //Next update is between 22 and 24 hours.
}
#endif // CLIENT_DLL
CBaseCombatWeapon *CCSGameRules::GetNextBestWeapon( CBaseCombatCharacter *pPlayer, CBaseCombatWeapon *pCurrentWeapon )
{
CBaseCombatWeapon *bestWeapon = NULL;
// search all the weapons looking for the closest next
for ( int i = 0; i < MAX_WEAPONS; i++ )
{
CBaseCombatWeapon *weapon = pPlayer->GetWeapon(i);
if ( !weapon )
continue;
if ( !weapon->CanBeSelected() || weapon == pCurrentWeapon )
continue;
#ifndef CLIENT_DLL
CCSPlayer *csPlayer = ToCSPlayer(pPlayer);
CWeaponCSBase *csWeapon = static_cast< CWeaponCSBase * >(weapon);
if ( csPlayer && csPlayer->IsBot() && !TheCSBots()->IsWeaponUseable( csWeapon ) )
continue;
#endif // CLIENT_DLL
if ( bestWeapon )
{
if ( weapon->GetSlot() < bestWeapon->GetSlot() )
{
bestWeapon = weapon;
}
else if ( weapon->GetSlot() == bestWeapon->GetSlot() && weapon->GetPosition() < bestWeapon->GetPosition() )
{
bestWeapon = weapon;
}
}
else
{
bestWeapon = weapon;
}
}
return bestWeapon;
}
float CCSGameRules::GetMapRemainingTime()
{
#ifdef GAME_DLL
if ( nextlevel.GetString() && *nextlevel.GetString() )
{
return 0;
}
#endif
// if timelimit is disabled, return -1
if ( mp_timelimit.GetInt() <= 0 )
return -1;
// timelimit is in minutes
float flTimeLeft = ( m_flGameStartTime + mp_timelimit.GetInt() * 60 ) - gpGlobals->curtime;
// never return a negative value
if ( flTimeLeft < 0 )
flTimeLeft = 0;
return flTimeLeft;
}
float CCSGameRules::GetMapElapsedTime( void )
{
return gpGlobals->curtime;
}
float CCSGameRules::GetRoundRemainingTime()
{
return (float) (m_fRoundStartTime + m_iRoundTime) - gpGlobals->curtime;
}
float CCSGameRules::GetRoundStartTime()
{
return m_fRoundStartTime;
}
float CCSGameRules::GetRoundElapsedTime()
{
return gpGlobals->curtime - m_fRoundStartTime;
}
bool CCSGameRules::ShouldCollide( int collisionGroup0, int collisionGroup1 )
{
if ( collisionGroup0 > collisionGroup1 )
{
// swap so that lowest is always first
::V_swap(collisionGroup0,collisionGroup1);
}
//Don't stand on COLLISION_GROUP_WEAPONs
if( collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT &&
collisionGroup1 == COLLISION_GROUP_WEAPON )
{
return false;
}
// TODO: make a CS-SPECIFIC COLLISION GROUP FOR PHYSICS PROPS THAT USE THIS COLLISION BEHAVIOR.
if ( (collisionGroup0 == COLLISION_GROUP_PLAYER || collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT) &&
collisionGroup1 == COLLISION_GROUP_PUSHAWAY )
{
return false;
}
if ( collisionGroup0 == COLLISION_GROUP_DEBRIS && collisionGroup1 == COLLISION_GROUP_PUSHAWAY )
{
// let debris and multiplayer objects collide
return true;
}
return BaseClass::ShouldCollide( collisionGroup0, collisionGroup1 );
}
bool CCSGameRules::IsFreezePeriod()
{
return m_bFreezePeriod;
}
bool CCSGameRules::IsVIPMap() const
{
//MIKETODO: VIP mode
return false;
}
bool CCSGameRules::IsBombDefuseMap() const
{
return m_bMapHasBombTarget;
}
bool CCSGameRules::IsHostageRescueMap() const
{
return m_bMapHasRescueZone;
}
bool CCSGameRules::IsLogoMap() const
{
return m_bLogoMap;
}
float CCSGameRules::GetBuyTimeLength() const
{
return ( mp_buytime.GetFloat() * 60 );
}
bool CCSGameRules::IsBuyTimeElapsed()
{
return ( GetRoundElapsedTime() > GetBuyTimeLength() );
}
int CCSGameRules::DefaultFOV()
{
return 90;
}
const CViewVectors* CCSGameRules::GetViewVectors() const
{
return &g_CSViewVectors;
}
//-----------------------------------------------------------------------------
// Purpose: Init CS ammo definitions
//-----------------------------------------------------------------------------
// 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 1
// 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)
static CCSAmmoDef ammoDef;
CCSAmmoDef* GetCSAmmoDef()
{
GetAmmoDef(); // to initialize the ammo info
return &ammoDef;
}
CAmmoDef* GetAmmoDef()
{
static bool bInitted = false;
if ( !bInitted )
{
bInitted = true;
ammoDef.AddAmmoType( BULLET_PLAYER_50AE, DMG_BULLET, TRACER_LINE, 0, 0, "ammo_50AE_max", 2400 * BULLET_IMPULSE_EXAGGERATION, 0, 10, 14 );
ammoDef.AddAmmoType( BULLET_PLAYER_762MM, DMG_BULLET, TRACER_LINE, 0, 0, "ammo_762mm_max", 2400 * BULLET_IMPULSE_EXAGGERATION, 0, 10, 14 );
ammoDef.AddAmmoType( BULLET_PLAYER_556MM, DMG_BULLET, TRACER_LINE, 0, 0, "ammo_556mm_max", 2400 * BULLET_IMPULSE_EXAGGERATION, 0, 10, 14 );
ammoDef.AddAmmoType( BULLET_PLAYER_556MM_BOX, DMG_BULLET, TRACER_LINE, 0, 0, "ammo_556mm_box_max",2400 * BULLET_IMPULSE_EXAGGERATION, 0, 10, 14 );
ammoDef.AddAmmoType( BULLET_PLAYER_338MAG, DMG_BULLET, TRACER_LINE, 0, 0, "ammo_338mag_max", 2800 * BULLET_IMPULSE_EXAGGERATION, 0, 12, 16 );
ammoDef.AddAmmoType( BULLET_PLAYER_9MM, DMG_BULLET, TRACER_LINE, 0, 0, "ammo_9mm_max", 2000 * BULLET_IMPULSE_EXAGGERATION, 0, 5, 10 );
ammoDef.AddAmmoType( BULLET_PLAYER_BUCKSHOT, DMG_BULLET, TRACER_LINE, 0, 0, "ammo_buckshot_max", 600 * BULLET_IMPULSE_EXAGGERATION, 0, 3, 6 );
ammoDef.AddAmmoType( BULLET_PLAYER_45ACP, DMG_BULLET, TRACER_LINE, 0, 0, "ammo_45acp_max", 2100 * BULLET_IMPULSE_EXAGGERATION, 0, 6, 10 );
ammoDef.AddAmmoType( BULLET_PLAYER_357SIG, DMG_BULLET, TRACER_LINE, 0, 0, "ammo_357sig_max", 2000 * BULLET_IMPULSE_EXAGGERATION, 0, 4, 8 );
ammoDef.AddAmmoType( BULLET_PLAYER_57MM, DMG_BULLET, TRACER_LINE, 0, 0, "ammo_57mm_max", 2000 * BULLET_IMPULSE_EXAGGERATION, 0, 4, 8 );
ammoDef.AddAmmoType( AMMO_TYPE_HEGRENADE, DMG_BLAST, TRACER_LINE, 0, 0, "ammo_hegrenade_max", 1, 0 );
ammoDef.AddAmmoType( AMMO_TYPE_FLASHBANG, 0, TRACER_LINE, 0, 0, "ammo_flashbang_max", 1, 0 );
ammoDef.AddAmmoType( AMMO_TYPE_SMOKEGRENADE, 0, TRACER_LINE, 0, 0, "ammo_smokegrenade_max", 1, 0 );
//Adrian: I set all the prices to 0 just so the rest of the buy code works
//This should be revisited.
ammoDef.AddAmmoCost( BULLET_PLAYER_50AE, 0, 7 );
ammoDef.AddAmmoCost( BULLET_PLAYER_762MM, 0, 30 );
ammoDef.AddAmmoCost( BULLET_PLAYER_556MM, 0, 30 );
ammoDef.AddAmmoCost( BULLET_PLAYER_556MM_BOX, 0, 30 );
ammoDef.AddAmmoCost( BULLET_PLAYER_338MAG, 0, 10 );
ammoDef.AddAmmoCost( BULLET_PLAYER_9MM, 0, 30 );
ammoDef.AddAmmoCost( BULLET_PLAYER_BUCKSHOT, 0, 8 );
ammoDef.AddAmmoCost( BULLET_PLAYER_45ACP, 0, 25 );
ammoDef.AddAmmoCost( BULLET_PLAYER_357SIG, 0, 13 );
ammoDef.AddAmmoCost( BULLET_PLAYER_57MM, 0, 50 );
}
return &ammoDef;
}
#ifndef CLIENT_DLL
const char *CCSGameRules::GetChatPrefix( bool bTeamOnly, CBasePlayer *pPlayer )
{
const char *pszPrefix = NULL;
if ( !pPlayer ) // dedicated server output
{
pszPrefix = "";
}
else
{
// team only
if ( bTeamOnly == TRUE )
{
if ( pPlayer->GetTeamNumber() == TEAM_CT )
{
if ( pPlayer->m_lifeState == LIFE_ALIVE )
{
pszPrefix = "(Counter-Terrorist)";
}
else
{
pszPrefix = "*DEAD*(Counter-Terrorist)";
}
}
else if ( pPlayer->GetTeamNumber() == TEAM_TERRORIST )
{
if ( pPlayer->m_lifeState == LIFE_ALIVE )
{
pszPrefix = "(Terrorist)";
}
else
{
pszPrefix = "*DEAD*(Terrorist)";
}
}
else if ( pPlayer->GetTeamNumber() == TEAM_SPECTATOR )
{
pszPrefix = "(Spectator)";
}
}
// everyone
else
{
if ( pPlayer->m_lifeState == LIFE_ALIVE )
{
pszPrefix = "";
}
else
{
if ( pPlayer->GetTeamNumber() != TEAM_SPECTATOR )
{
pszPrefix = "*DEAD*";
}
else
{
pszPrefix = "*SPEC*";
}
}
}
}
return pszPrefix;
}
const char *CCSGameRules::GetChatLocation( bool bTeamOnly, CBasePlayer *pPlayer )
{
if ( !pPlayer ) // dedicated server output
{
return NULL;
}
// only teammates see locations
if ( !bTeamOnly )
return NULL;
// only living players have locations
if ( pPlayer->GetTeamNumber() != TEAM_CT && pPlayer->GetTeamNumber() != TEAM_TERRORIST )
return NULL;
if ( !pPlayer->IsAlive() )
return NULL;
return pPlayer->GetLastKnownPlaceName();
}
const char *CCSGameRules::GetChatFormat( bool bTeamOnly, CBasePlayer *pPlayer )
{
if ( !pPlayer ) // dedicated server output
{
return NULL;
}
const char *pszFormat = NULL;
// team only
if ( bTeamOnly == TRUE )
{
if ( pPlayer->GetTeamNumber() == TEAM_CT )
{
if ( pPlayer->m_lifeState == LIFE_ALIVE )
{
const char *chatLocation = GetChatLocation( bTeamOnly, pPlayer );
if ( chatLocation && *chatLocation )
{
pszFormat = "Cstrike_Chat_CT_Loc";
}
else
{
pszFormat = "Cstrike_Chat_CT";
}
}
else
{
pszFormat = "Cstrike_Chat_CT_Dead";
}
}
else if ( pPlayer->GetTeamNumber() == TEAM_TERRORIST )
{
if ( pPlayer->m_lifeState == LIFE_ALIVE )
{
const char *chatLocation = GetChatLocation( bTeamOnly, pPlayer );
if ( chatLocation && *chatLocation )
{
pszFormat = "Cstrike_Chat_T_Loc";
}
else
{
pszFormat = "Cstrike_Chat_T";
}
}
else
{
pszFormat = "Cstrike_Chat_T_Dead";
}
}
else if ( pPlayer->GetTeamNumber() == TEAM_SPECTATOR )
{
pszFormat = "Cstrike_Chat_Spec";
}
}
// everyone
else
{
if ( pPlayer->m_lifeState == LIFE_ALIVE )
{
pszFormat = "Cstrike_Chat_All";
}
else
{
if ( pPlayer->GetTeamNumber() != TEAM_SPECTATOR )
{
pszFormat = "Cstrike_Chat_AllDead";
}
else
{
pszFormat = "Cstrike_Chat_AllSpec";
}
}
}
return pszFormat;
}
void CCSGameRules::ClientSettingsChanged( CBasePlayer *pPlayer )
{
const char *pszNewName = engine->GetClientConVarValue( pPlayer->entindex(), "name" );
const char *pszOldName = pPlayer->GetPlayerName();
CCSPlayer *pCSPlayer = (CCSPlayer*)pPlayer;
if ( pszOldName[0] != 0 && Q_strncmp( pszOldName, pszNewName, MAX_PLAYER_NAME_LENGTH-1 ) )
{
pCSPlayer->ChangeName( pszNewName );
}
pCSPlayer->m_bShowHints = true;
if ( pCSPlayer->IsNetClient() )
{
const char *pShowHints = engine->GetClientConVarValue( engine->IndexOfEdict( pCSPlayer->edict() ), "cl_autohelp" );
if ( pShowHints && atoi( pShowHints ) <= 0 )
{
pCSPlayer->m_bShowHints = false;
}
}
}
bool CCSGameRules::FAllowNPCs( void )
{
return false;
}
bool CCSGameRules::IsFriendlyFireOn( void )
{
return friendlyfire.GetBool();
}
CON_COMMAND( map_showspawnpoints, "Shows player spawn points (red=invalid)" )
{
CSGameRules()->ShowSpawnPoints();
}
void DrawSphere( const Vector& pos, float radius, int r, int g, int b, float lifetime )
{
Vector edge, lastEdge;
NDebugOverlay::Line( pos, pos + Vector( 0, 0, 50 ), r, g, b, true, lifetime );
lastEdge = Vector( radius + pos.x, pos.y, pos.z );
float angle;
for( angle=0.0f; angle <= 360.0f; angle += 22.5f )
{
edge.x = radius * BotCOS( angle ) + pos.x;
edge.y = pos.y;
edge.z = radius * BotSIN( angle ) + pos.z;
NDebugOverlay::Line( edge, lastEdge, r, g, b, true, lifetime );
lastEdge = edge;
}
lastEdge = Vector( pos.x, radius + pos.y, pos.z );
for( angle=0.0f; angle <= 360.0f; angle += 22.5f )
{
edge.x = pos.x;
edge.y = radius * BotCOS( angle ) + pos.y;
edge.z = radius * BotSIN( angle ) + pos.z;
NDebugOverlay::Line( edge, lastEdge, r, g, b, true, lifetime );
lastEdge = edge;
}
lastEdge = Vector( pos.x, radius + pos.y, pos.z );
for( angle=0.0f; angle <= 360.0f; angle += 22.5f )
{
edge.x = radius * BotCOS( angle ) + pos.x;
edge.y = radius * BotSIN( angle ) + pos.y;
edge.z = pos.z;
NDebugOverlay::Line( edge, lastEdge, r, g, b, true, lifetime );
lastEdge = edge;
}
}
CON_COMMAND_F( map_showbombradius, "Shows bomb radius from the center of each bomb site and planted bomb.", FCVAR_CHEAT )
{
float flBombDamage = 500.0f;
if ( g_pMapInfo )
flBombDamage = g_pMapInfo->m_flBombRadius;
float flBombRadius = flBombDamage * 3.5f;
Msg( "Bomb Damage is %.0f, Radius is %.0f\n", flBombDamage, flBombRadius );
CBaseEntity* ent = NULL;
while ( ( ent = gEntList.FindEntityByClassname( ent, "func_bomb_target" ) ) != NULL )
{
const Vector &pos = ent->WorldSpaceCenter();
DrawSphere( pos, flBombRadius, 255, 255, 0, 10 );
}
ent = NULL;
while ( ( ent = gEntList.FindEntityByClassname( ent, "planted_c4" ) ) != NULL )
{
const Vector &pos = ent->WorldSpaceCenter();
DrawSphere( pos, flBombRadius, 255, 0, 0, 10 );
}
}
CON_COMMAND_F( map_setbombradius, "Sets the bomb radius for the map.", FCVAR_CHEAT )
{
if ( args.ArgC() != 2 )
return;
if ( !UTIL_IsCommandIssuedByServerAdmin() )
return;
if ( !g_pMapInfo )
CBaseEntity::Create( "info_map_parameters", vec3_origin, vec3_angle );
if ( !g_pMapInfo )
return;
g_pMapInfo->m_flBombRadius = atof( args[1] );
map_showbombradius( args );
}
void CreateBlackMarketString( void )
{
g_StringTableBlackMarket = networkstringtable->CreateStringTable( "BlackMarketTable" , 1 );
}
int CCSGameRules::GetStartMoney( void )
{
if ( IsBlackMarket() )
{
return atoi( mp_startmoney.GetDefault() );
}
return mp_startmoney.GetInt();
}
//=============================================================================
// HPE_BEGIN:
// [menglish] Set up anything for all players that changes based on new players spawning mid-game
// Find and return fun fact data
//=============================================================================
//-----------------------------------------------------------------------------
// Purpose: Called when a player joins the game after it's started yet can still spawn in
//-----------------------------------------------------------------------------
void CCSGameRules::SpawningLatePlayer( CCSPlayer* pLatePlayer )
{
//Reset the round kills number of enemies for the opposite team
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CCSPlayer *pPlayer = (CCSPlayer*) UTIL_PlayerByIndex( i );
if(pPlayer)
{
if(pPlayer->GetTeamNumber() == pLatePlayer->GetTeamNumber())
{
continue;
}
pPlayer->m_NumEnemiesAtRoundStart++;
}
}
}
//=============================================================================
// HPE_END
//=============================================================================
//=============================================================================
// HPE_BEGIN:
// [pfreese] Test for "pistol" round, defined as the default starting round
// when players cannot purchase anything primary weapons
//=============================================================================
bool CCSGameRules::IsPistolRound()
{
return m_iTotalRoundsPlayed == 0 && GetStartMoney() <= 800;
}
//=============================================================================
// HPE_END
//=============================================================================
//=============================================================================
// HPE_BEGIN:
// [tj] So game rules can react to damage taken
// [menglish]
//=============================================================================
void CCSGameRules::PlayerTookDamage(CCSPlayer* player, const CTakeDamageInfo &damageInfo)
{
CBaseEntity *pInflictor = damageInfo.GetInflictor();
CBaseEntity *pAttacker = damageInfo.GetAttacker();
CCSPlayer *pCSScorer = (CCSPlayer *)(GetDeathScorer( pAttacker, pInflictor ));
if ( player && pCSScorer )
{
if (player->GetTeamNumber() == TEAM_CT)
{
m_bNoCTsDamaged = false;
}
if (player->GetTeamNumber() == TEAM_TERRORIST)
{
m_bNoTerroristsDamaged = false;
}
// set the first blood if this is the first and the victim is on a different team then the player
if ( m_pFirstBlood == NULL && pCSScorer != player && pCSScorer->GetTeamNumber() != player ->GetTeamNumber() )
{
m_pFirstBlood = pCSScorer;
m_firstBloodTime = gpGlobals->curtime - m_fRoundStartTime;
}
}
}
//=============================================================================
// HPE_END
//=============================================================================
#endif
bool CCSGameRules::IsConnectedUserInfoChangeAllowed( CBasePlayer *pPlayer )
{
#ifdef GAME_DLL
if( pPlayer )
{
int iPlayerTeam = pPlayer->GetTeamNumber();
if( ( iPlayerTeam == TEAM_CT ) || ( iPlayerTeam == TEAM_TERRORIST ) )
return false;
}
#else
int iLocalPlayerTeam = GetLocalPlayerTeam();
if( ( iLocalPlayerTeam == TEAM_CT ) || ( iLocalPlayerTeam == TEAM_TERRORIST ) )
return false;
#endif
return true;
}
#ifdef GAME_DLL
struct convar_tags_t
{
const char *pszConVar;
const char *pszTag;
};
// The list of convars that automatically turn on tags when they're changed.
// Convars in this list need to have the FCVAR_NOTIFY flag set on them, so the
// tags are recalculated and uploaded to the master server when the convar is changed.
convar_tags_t convars_to_check_for_tags[] =
{
{ "mp_friendlyfire", "friendlyfire" },
{ "bot_quota", "bots" },
{ "sv_nostats", "nostats" },
{ "mp_startmoney", "startmoney" },
{ "sv_allowminmodels", "nominmodels" },
{ "sv_enablebunnyhopping", "bunnyhopping" },
{ "sv_competitive_minspec", "compspec" },
{ "mp_holiday_nogifts", "nogifts" },
};
//-----------------------------------------------------------------------------
// Purpose: Engine asks for the list of convars that should tag the server
//-----------------------------------------------------------------------------
void CCSGameRules::GetTaggedConVarList( KeyValues *pCvarTagList )
{
BaseClass::GetTaggedConVarList( pCvarTagList );
for ( int i = 0; i < ARRAYSIZE(convars_to_check_for_tags); i++ )
{
KeyValues *pKV = new KeyValues( "tag" );
pKV->SetString( "convar", convars_to_check_for_tags[i].pszConVar );
pKV->SetString( "tag", convars_to_check_for_tags[i].pszTag );
pCvarTagList->AddSubKey( pKV );
}
}
#endif
int CCSGameRules::GetBlackMarketPriceForWeapon( int iWeaponID )
{
if ( m_pPrices == NULL )
{
GetBlackMarketPriceList();
}
if ( m_pPrices )
return m_pPrices->iCurrentPrice[iWeaponID];
else
return 0;
}
int CCSGameRules::GetBlackMarketPreviousPriceForWeapon( int iWeaponID )
{
if ( m_pPrices == NULL )
{
GetBlackMarketPriceList();
}
if ( m_pPrices )
return m_pPrices->iPreviousPrice[iWeaponID];
else
return 0;
}
const weeklyprice_t *CCSGameRules::GetBlackMarketPriceList( void )
{
if ( m_StringTableBlackMarket == NULL )
{
m_StringTableBlackMarket = networkstringtable->FindTable( CS_GAMERULES_BLACKMARKET_TABLE_NAME);
}
if ( m_pPrices == NULL )
{
int iSize = 0;
INetworkStringTable *pTable = m_StringTableBlackMarket;
if ( pTable && pTable->GetNumStrings() > 0 )
{
m_pPrices = (const weeklyprice_t *)pTable->GetStringUserData( 0, &iSize );
}
}
if ( m_pPrices )
{
PrepareEquipmentInfo();
}
return m_pPrices;
}
void CCSGameRules::SetBlackMarketPrices( bool bSetDefaults )
{
for ( int i = 1; i < WEAPON_MAX; i++ )
{
if ( i == WEAPON_SHIELDGUN )
continue;
CCSWeaponInfo *info = GetWeaponInfo( (CSWeaponID)i );
if ( info == NULL )
continue;
if ( bSetDefaults == false )
{
info->SetWeaponPrice( GetBlackMarketPriceForWeapon( i ) );
info->SetPreviousPrice( GetBlackMarketPreviousPriceForWeapon( i ) );
}
else
{
info->SetWeaponPrice( info->GetDefaultPrice() );
}
}
}
#ifdef CLIENT_DLL
CCSGameRules::CCSGameRules()
{
CSGameRules()->m_StringTableBlackMarket = NULL;
m_pPrices = NULL;
m_bBlackMarket = false;
}
void TestTable( void )
{
CSGameRules()->m_StringTableBlackMarket = networkstringtable->FindTable( CS_GAMERULES_BLACKMARKET_TABLE_NAME);
if ( CSGameRules()->m_StringTableBlackMarket == NULL )
return;
int iIndex = CSGameRules()->m_StringTableBlackMarket->FindStringIndex( "blackmarket_prices" );
int iSize = 0;
const weeklyprice_t *pPrices = NULL;
pPrices = (const weeklyprice_t *)(CSGameRules()->m_StringTableBlackMarket)->GetStringUserData( iIndex, &iSize );
}
#ifdef DEBUG
ConCommand cs_testtable( "cs_testtable", TestTable );
#endif
//-----------------------------------------------------------------------------
// Enforce certain values on the specified convar.
//-----------------------------------------------------------------------------
void EnforceCompetitiveCVar( const char *szCvarName, float fMinValue, float fMaxValue = FLT_MAX, int iArgs = 0, ... )
{
// Doing this check first because OK values might be outside the min/max range
ConVarRef competitiveConvar(szCvarName);
float fValue = competitiveConvar.GetFloat();
va_list vl;
va_start(vl, iArgs);
for( int i=0; i< iArgs; ++i )
{
if( (int)fValue == (int)va_arg(vl,double) )
return;
}
va_end(vl);
if( fValue < fMinValue || fValue > fMaxValue )
{
float fNewValue = MAX( MIN( fValue, fMaxValue ), fMinValue );
competitiveConvar.SetValue( fNewValue );
DevMsg( "Convar %s enforced by server (see sv_competitive_minspec.) Set to %2f.\n", szCvarName, fNewValue );
}
}
//-----------------------------------------------------------------------------
// An interface used by ENABLE_COMPETITIVE_CONVAR macro that lets the classes
// defined in the macro to be stored and acted on.
//-----------------------------------------------------------------------------
class ICompetitiveConvar
{
public:
// It is a best practice to always have a virtual destructor in an interface
// class. Otherwise if the derived classes have destructors they will not be
// called.
virtual ~ICompetitiveConvar() {}
virtual void BackupConvar() = 0;
virtual void EnforceRestrictions() = 0;
virtual void RestoreOriginalValue() = 0;
virtual void InstallChangeCallback() = 0;
};
//-----------------------------------------------------------------------------
// A manager for all enforced competitive convars.
//-----------------------------------------------------------------------------
class CCompetitiveCvarManager : public CAutoGameSystem
{
public:
typedef CUtlVector<ICompetitiveConvar*> CompetitiveConvarList_t;
static void AddConvarToList( ICompetitiveConvar* pCVar )
{
GetConvarList()->AddToTail( pCVar );
}
static void BackupAllConvars()
{
FOR_EACH_VEC( *GetConvarList(), i )
{
(*GetConvarList())[i]->BackupConvar();
}
}
static void EnforceRestrictionsOnAllConvars()
{
FOR_EACH_VEC( *GetConvarList(), i )
{
(*GetConvarList())[i]->EnforceRestrictions();
}
}
static void RestoreAllOriginalValues()
{
FOR_EACH_VEC( *GetConvarList(), i )
{
(*GetConvarList())[i]->RestoreOriginalValue();
}
}
static CompetitiveConvarList_t* GetConvarList()
{
if( !s_pCompetitiveConvars )
{
s_pCompetitiveConvars = new CompetitiveConvarList_t();
}
return s_pCompetitiveConvars;
}
static KeyValues* GetConVarBackupKV()
{
if( !s_pConVarBackups )
{
s_pConVarBackups = new KeyValues("ConVarBackups");
}
return s_pConVarBackups;
}
virtual bool Init()
{
FOR_EACH_VEC( *GetConvarList(), i )
{
(*GetConvarList())[i]->InstallChangeCallback();
}
return true;
}
virtual void Shutdown()
{
FOR_EACH_VEC( *GetConvarList(), i )
{
delete (*GetConvarList())[i];
}
delete s_pCompetitiveConvars;
s_pCompetitiveConvars = null;
s_pConVarBackups->deleteThis();
s_pConVarBackups = null;
}
private:
static CompetitiveConvarList_t* s_pCompetitiveConvars;
static KeyValues* s_pConVarBackups;
};
static CCompetitiveCvarManager *s_pCompetitiveCvarManager = new CCompetitiveCvarManager();
CCompetitiveCvarManager::CompetitiveConvarList_t* CCompetitiveCvarManager::s_pCompetitiveConvars = null;
KeyValues* CCompetitiveCvarManager::s_pConVarBackups = null;
//-----------------------------------------------------------------------------
// Macro to define restrictions on convars with "sv_competitive_minspec 1"
// Usage: ENABLE_COMPETITIVE_CONVAR( convarName, minValue, maxValue, optionalValues, opVal1, opVal2, ...
//-----------------------------------------------------------------------------
#define ENABLE_COMPETITIVE_CONVAR( convarName, ... ) \
class CCompetitiveMinspecConvar##convarName : public ICompetitiveConvar { \
public: \
CCompetitiveMinspecConvar##convarName(){ CCompetitiveCvarManager::AddConvarToList(this);} \
static void on_changed_##convarName( IConVar *var, const char *pOldValue, float flOldValue ){ \
if( sv_competitive_minspec.GetBool() ) { \
EnforceCompetitiveCVar( #convarName , __VA_ARGS__ ); }\
else {\
CCompetitiveCvarManager::GetConVarBackupKV()->SetFloat( #convarName, ConVarRef( #convarName ).GetFloat() ); } } \
virtual void BackupConvar() { CCompetitiveCvarManager::GetConVarBackupKV()->SetFloat( #convarName, ConVarRef( #convarName ).GetFloat() ); } \
virtual void EnforceRestrictions() { EnforceCompetitiveCVar( #convarName , __VA_ARGS__ ); } \
virtual void RestoreOriginalValue() { ConVarRef(#convarName).SetValue(CCompetitiveCvarManager::GetConVarBackupKV()->GetFloat( #convarName ) ); } \
virtual void InstallChangeCallback() { static_cast<ConVar*>(ConVarRef( #convarName ).GetLinkedConVar())->InstallChangeCallback( CCompetitiveMinspecConvar##convarName::on_changed_##convarName); } \
}; \
static CCompetitiveMinspecConvar##convarName *s_pCompetitiveConvar##convarName = new CCompetitiveMinspecConvar##convarName();
//-----------------------------------------------------------------------------
// Callback function for sv_competitive_minspec convar value change.
//-----------------------------------------------------------------------------
void sv_competitive_minspec_changed_f( IConVar *var, const char *pOldValue, float flOldValue )
{
ConVar *pCvar = static_cast<ConVar*>(var);
if( pCvar->GetBool() == true && (bool)flOldValue == false )
{
// Backup the values of each cvar and enforce new ones
CCompetitiveCvarManager::BackupAllConvars();
CCompetitiveCvarManager::EnforceRestrictionsOnAllConvars();
}
else if( pCvar->GetBool() == false && (bool)flOldValue == true )
{
// If sv_competitive_minspec is disabled, restore old client values
CCompetitiveCvarManager::RestoreAllOriginalValues();
}
}
#endif
static ConVar sv_competitive_minspec( "sv_competitive_minspec",
"0",
FCVAR_REPLICATED | FCVAR_NOTIFY,
"Enable to force certain client convars to minimum/maximum values to help prevent competitive advantages:\n \
r_drawdetailprops = 1\n \
r_staticprop_lod = minimum -1 maximum 3\n \
fps_max minimum 59 (0 works too)\n \
cl_detailfade minimum 400\n \
cl_detaildist minimum 1200\n \
cl_interp_ratio = minimum 1 maximum 2\n \
cl_interp = minimum 0 maximum 0.031\n \
"
#ifdef CLIENT_DLL
,sv_competitive_minspec_changed_f
#endif
);
#ifdef CLIENT_DLL
ENABLE_COMPETITIVE_CONVAR( r_drawdetailprops, true, true ); // force r_drawdetailprops on
ENABLE_COMPETITIVE_CONVAR( r_staticprop_lod, -1, 3 ); // force r_staticprop_lod from -1 to 3
ENABLE_COMPETITIVE_CONVAR( fps_max, 59, FLT_MAX, 1, 0 ); // force fps_max above 59. One additional value (0) works
ENABLE_COMPETITIVE_CONVAR( cl_detailfade, 400 ); // force cl_detailfade above 400.
ENABLE_COMPETITIVE_CONVAR( cl_detaildist, 1200 ); // force cl_detaildist above 1200.
ENABLE_COMPETITIVE_CONVAR( cl_interp_ratio, 1, 2 ); // force cl_interp_ratio from 1 to 2
ENABLE_COMPETITIVE_CONVAR( cl_interp, 0, 0.031 ); // force cl_interp from 0.0152 to 0.031
// Stubs for replay client code
const char *GetMapDisplayName( const char *pMapName )
{
return pMapName;
}
bool IsTakingAFreezecamScreenshot()
{
return false;
}
#endif