1876 lines
55 KiB
C++
1876 lines
55 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Contains the implementation of game rules for multiplayer.
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "cdll_int.h"
|
|
#include "multiplay_gamerules.h"
|
|
#include "viewport_panel_names.h"
|
|
#include "gameeventdefs.h"
|
|
#include <KeyValues.h>
|
|
#include "filesystem.h"
|
|
#include "mp_shareddefs.h"
|
|
#include "utlbuffer.h"
|
|
|
|
#ifdef CLIENT_DLL
|
|
|
|
#else
|
|
|
|
#include "eventqueue.h"
|
|
#include "player.h"
|
|
#include "basecombatweapon.h"
|
|
#include "gamerules.h"
|
|
#include "game.h"
|
|
#include "items.h"
|
|
#include "entitylist.h"
|
|
#include "in_buttons.h"
|
|
#include <ctype.h>
|
|
#include "voice_gamemgr.h"
|
|
#include "iscorer.h"
|
|
#include "hltvdirector.h"
|
|
#include "AI_Criteria.h"
|
|
#include "sceneentity.h"
|
|
#include "basemultiplayerplayer.h"
|
|
#include "team.h"
|
|
#include "usermessages.h"
|
|
#include "tier0/icommandline.h"
|
|
|
|
#ifdef NEXT_BOT
|
|
#include "NextBotManager.h"
|
|
#endif
|
|
|
|
// TODO Why did we add this to the base class guys.
|
|
#if defined ( TF_DLL ) || defined ( TF_CLIENT_DLL )
|
|
#include "player_vs_environment/tf_population_manager.h"
|
|
#endif
|
|
|
|
#endif
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
|
|
REGISTER_GAMERULES_CLASS( CMultiplayRules );
|
|
|
|
ConVar mp_chattime(
|
|
"mp_chattime",
|
|
"10",
|
|
FCVAR_REPLICATED,
|
|
"amount of time players can chat after the game is over",
|
|
true, 1,
|
|
true, 120 );
|
|
|
|
#ifdef GAME_DLL
|
|
void MPTimeLimitCallback( IConVar *var, const char *pOldString, float flOldValue )
|
|
{
|
|
if ( mp_timelimit.GetInt() < 0 )
|
|
{
|
|
mp_timelimit.SetValue( 0 );
|
|
}
|
|
|
|
if ( MultiplayRules() )
|
|
{
|
|
MultiplayRules()->HandleTimeLimitChange();
|
|
}
|
|
}
|
|
#endif
|
|
|
|
ConVar mp_timelimit( "mp_timelimit", "0", FCVAR_NOTIFY|FCVAR_REPLICATED, "game time per map in minutes"
|
|
#ifdef GAME_DLL
|
|
, MPTimeLimitCallback
|
|
#endif
|
|
);
|
|
|
|
ConVar fraglimit( "mp_fraglimit","0", FCVAR_NOTIFY|FCVAR_REPLICATED, "The number of kills at which the map ends");
|
|
|
|
ConVar mp_show_voice_icons( "mp_show_voice_icons", "1", FCVAR_REPLICATED, "Show overhead player voice icons when players are speaking.\n" );
|
|
|
|
#ifdef GAME_DLL
|
|
|
|
ConVar tv_delaymapchange( "tv_delaymapchange", "0", FCVAR_NONE, "Delays map change until broadcast is complete" );
|
|
ConVar tv_delaymapchange_protect( "tv_delaymapchange_protect", "1", FCVAR_NONE, "Protect against doing a manual map change if HLTV is broadcasting and has not caught up with a major game event such as round_end" );
|
|
|
|
ConVar mp_restartgame( "mp_restartgame", "0", FCVAR_GAMEDLL, "If non-zero, game will restart in the specified number of seconds" );
|
|
ConVar mp_restartgame_immediate( "mp_restartgame_immediate", "0", FCVAR_GAMEDLL, "If non-zero, game will restart immediately" );
|
|
|
|
ConVar mp_mapcycle_empty_timeout_seconds( "mp_mapcycle_empty_timeout_seconds", "0", FCVAR_REPLICATED, "If nonzero, server will cycle to the next map if it has been empty on the current map for N seconds");
|
|
|
|
void cc_SkipNextMapInCycle()
|
|
{
|
|
if ( !UTIL_IsCommandIssuedByServerAdmin() )
|
|
return;
|
|
|
|
if ( MultiplayRules() )
|
|
{
|
|
MultiplayRules()->SkipNextMapInCycle();
|
|
}
|
|
}
|
|
|
|
void cc_GotoNextMapInCycle()
|
|
{
|
|
if ( !UTIL_IsCommandIssuedByServerAdmin() )
|
|
return;
|
|
|
|
if ( MultiplayRules() )
|
|
{
|
|
MultiplayRules()->ChangeLevel();
|
|
}
|
|
}
|
|
|
|
ConCommand skip_next_map( "skip_next_map", cc_SkipNextMapInCycle, "Skips the next map in the map rotation for the server." );
|
|
ConCommand changelevel_next( "changelevel_next", cc_GotoNextMapInCycle, "Immediately changes to the next map in the map rotation for the server." );
|
|
|
|
#ifndef TF_DLL // TF overrides the default value of this convar
|
|
ConVar mp_waitingforplayers_time( "mp_waitingforplayers_time", "0", FCVAR_GAMEDLL, "WaitingForPlayers time length in seconds" );
|
|
#endif
|
|
|
|
ConVar mp_waitingforplayers_restart( "mp_waitingforplayers_restart", "0", FCVAR_GAMEDLL, "Set to 1 to start or restart the WaitingForPlayers period." );
|
|
ConVar mp_waitingforplayers_cancel( "mp_waitingforplayers_cancel", "0", FCVAR_GAMEDLL, "Set to 1 to end the WaitingForPlayers period." );
|
|
ConVar mp_clan_readyrestart( "mp_clan_readyrestart", "0", FCVAR_GAMEDLL, "If non-zero, game will restart once someone from each team gives the ready signal" );
|
|
ConVar mp_clan_ready_signal( "mp_clan_ready_signal", "ready", FCVAR_GAMEDLL, "Text that team leader from each team must speak for the match to begin" );
|
|
|
|
ConVar nextlevel( "nextlevel",
|
|
"",
|
|
FCVAR_GAMEDLL | FCVAR_NOTIFY,
|
|
#if defined( CSTRIKE_DLL ) || defined( TF_DLL )
|
|
"If set to a valid map name, will trigger a changelevel to the specified map at the end of the round" );
|
|
#else
|
|
"If set to a valid map name, will change to this map during the next changelevel" );
|
|
#endif // CSTRIKE_DLL || TF_DLL
|
|
|
|
#endif
|
|
|
|
#ifndef CLIENT_DLL
|
|
int CMultiplayRules::m_nMapCycleTimeStamp = 0;
|
|
int CMultiplayRules::m_nMapCycleindex = 0;
|
|
CUtlVector<char*> CMultiplayRules::m_MapList;
|
|
#endif
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
bool CMultiplayRules::IsMultiplayer( void )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CMultiplayRules::Damage_GetTimeBased( void )
|
|
{
|
|
int iDamage = ( DMG_PARALYZE | DMG_NERVEGAS | DMG_POISON | DMG_RADIATION | DMG_DROWNRECOVER | DMG_ACID | DMG_SLOWBURN );
|
|
return iDamage;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CMultiplayRules::Damage_GetShouldGibCorpse( void )
|
|
{
|
|
int iDamage = ( DMG_CRUSH | DMG_FALL | DMG_BLAST | DMG_SONIC | DMG_CLUB );
|
|
return iDamage;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CMultiplayRules::Damage_GetShowOnHud( void )
|
|
{
|
|
int iDamage = ( DMG_POISON | DMG_ACID | DMG_DROWN | DMG_BURN | DMG_SLOWBURN | DMG_NERVEGAS | DMG_RADIATION | DMG_SHOCK );
|
|
return iDamage;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CMultiplayRules::Damage_GetNoPhysicsForce( void )
|
|
{
|
|
int iTimeBasedDamage = Damage_GetTimeBased();
|
|
int iDamage = ( DMG_FALL | DMG_BURN | DMG_PLASMA | DMG_DROWN | iTimeBasedDamage | DMG_CRUSH | DMG_PHYSGUN | DMG_PREVENT_PHYSICS_FORCE );
|
|
return iDamage;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CMultiplayRules::Damage_GetShouldNotBleed( void )
|
|
{
|
|
int iDamage = ( DMG_POISON | DMG_ACID );
|
|
return iDamage;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : iDmgType -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CMultiplayRules::Damage_IsTimeBased( int iDmgType )
|
|
{
|
|
// Damage types that are time-based.
|
|
return ( ( iDmgType & ( DMG_PARALYZE | DMG_NERVEGAS | DMG_POISON | DMG_RADIATION | DMG_DROWNRECOVER | DMG_ACID | DMG_SLOWBURN ) ) != 0 );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : iDmgType -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CMultiplayRules::Damage_ShouldGibCorpse( int iDmgType )
|
|
{
|
|
// Damage types that gib the corpse.
|
|
return ( ( iDmgType & ( DMG_CRUSH | DMG_FALL | DMG_BLAST | DMG_SONIC | DMG_CLUB ) ) != 0 );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : iDmgType -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CMultiplayRules::Damage_ShowOnHUD( int iDmgType )
|
|
{
|
|
// Damage types that have client HUD art.
|
|
return ( ( iDmgType & ( DMG_POISON | DMG_ACID | DMG_DROWN | DMG_BURN | DMG_SLOWBURN | DMG_NERVEGAS | DMG_RADIATION | DMG_SHOCK ) ) != 0 );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : iDmgType -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CMultiplayRules::Damage_NoPhysicsForce( int iDmgType )
|
|
{
|
|
// Damage types that don't have to supply a physics force & position.
|
|
int iTimeBasedDamage = Damage_GetTimeBased();
|
|
return ( ( iDmgType & ( DMG_FALL | DMG_BURN | DMG_PLASMA | DMG_DROWN | iTimeBasedDamage | DMG_CRUSH | DMG_PHYSGUN | DMG_PREVENT_PHYSICS_FORCE ) ) != 0 );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : iDmgType -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CMultiplayRules::Damage_ShouldNotBleed( int iDmgType )
|
|
{
|
|
// Damage types that don't make the player bleed.
|
|
return ( ( iDmgType & ( DMG_POISON | DMG_ACID ) ) != 0 );
|
|
}
|
|
|
|
//*********************************************************
|
|
// Rules for the half-life multiplayer game.
|
|
//*********************************************************
|
|
CMultiplayRules::CMultiplayRules()
|
|
{
|
|
#ifndef CLIENT_DLL
|
|
m_flTimeLastMapChangeOrPlayerWasConnected = 0.0f;
|
|
|
|
RefreshSkillData( true );
|
|
|
|
// 11/8/98
|
|
// Modified by YWB: Server .cfg file is now a cvar, so that
|
|
// server ops can run multiple game servers, with different server .cfg files,
|
|
// from a single installed directory.
|
|
// Mapcyclefile is already a cvar.
|
|
|
|
// 3/31/99
|
|
// Added lservercfg file cvar, since listen and dedicated servers should not
|
|
// share a single config file. (sjb)
|
|
if ( engine->IsDedicatedServer() )
|
|
{
|
|
// dedicated server
|
|
const char *cfgfile = servercfgfile.GetString();
|
|
|
|
if ( cfgfile && cfgfile[0] )
|
|
{
|
|
char szCommand[MAX_PATH];
|
|
|
|
Log( "Executing dedicated server config file %s\n", cfgfile );
|
|
Q_snprintf( szCommand,sizeof(szCommand), "exec %s\n", cfgfile );
|
|
engine->ServerCommand( szCommand );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// listen server
|
|
const char *cfgfile = lservercfgfile.GetString();
|
|
|
|
if ( cfgfile && cfgfile[0] )
|
|
{
|
|
char szCommand[MAX_PATH];
|
|
|
|
Log( "Executing listen server config file %s\n", cfgfile );
|
|
Q_snprintf( szCommand,sizeof(szCommand), "exec %s\n", cfgfile );
|
|
engine->ServerCommand( szCommand );
|
|
}
|
|
}
|
|
|
|
nextlevel.SetValue( "" );
|
|
LoadMapCycleFile();
|
|
|
|
#endif
|
|
|
|
LoadVoiceCommandScript();
|
|
}
|
|
|
|
bool CMultiplayRules::Init()
|
|
{
|
|
#ifdef GAME_DLL
|
|
|
|
// Initialize the custom response rule dictionaries.
|
|
InitCustomResponseRulesDicts();
|
|
|
|
#endif
|
|
|
|
return BaseClass::Init();
|
|
}
|
|
|
|
|
|
#ifdef CLIENT_DLL
|
|
|
|
|
|
#else
|
|
|
|
extern bool g_fGameOver;
|
|
|
|
#define ITEM_RESPAWN_TIME 30
|
|
#define WEAPON_RESPAWN_TIME 20
|
|
#define AMMO_RESPAWN_TIME 20
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
void CMultiplayRules::RefreshSkillData( bool forceUpdate )
|
|
{
|
|
// load all default values
|
|
BaseClass::RefreshSkillData( forceUpdate );
|
|
|
|
// override some values for multiplay.
|
|
|
|
// suitcharger
|
|
#ifndef TF_DLL
|
|
//=============================================================================
|
|
// HPE_BEGIN:
|
|
// [menglish] CS doesn't have the suitcharger either
|
|
//=============================================================================
|
|
#ifndef CSTRIKE_DLL
|
|
ConVarRef suitcharger( "sk_suitcharger" );
|
|
suitcharger.SetValue( 30 );
|
|
#endif
|
|
//=============================================================================
|
|
// HPE_END
|
|
//=============================================================================
|
|
#endif
|
|
}
|
|
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
void CMultiplayRules::Think ( void )
|
|
{
|
|
BaseClass::Think();
|
|
|
|
///// Check game rules /////
|
|
|
|
if ( g_fGameOver ) // someone else quit the game already
|
|
{
|
|
ChangeLevel(); // intermission is over
|
|
return;
|
|
}
|
|
|
|
float flTimeLimit = mp_timelimit.GetFloat() * 60;
|
|
float flFragLimit = fraglimit.GetFloat();
|
|
|
|
if ( flTimeLimit != 0 && gpGlobals->curtime >= flTimeLimit )
|
|
{
|
|
GoToIntermission();
|
|
return;
|
|
}
|
|
|
|
if ( flFragLimit )
|
|
{
|
|
// check if any player is over the frag limit
|
|
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
|
|
{
|
|
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
|
|
|
|
if ( pPlayer && pPlayer->FragCount() >= flFragLimit )
|
|
{
|
|
GoToIntermission();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
void CMultiplayRules::FrameUpdatePostEntityThink()
|
|
{
|
|
BaseClass::FrameUpdatePostEntityThink();
|
|
|
|
float flNow = Plat_FloatTime();
|
|
|
|
// Update time when client was last connected
|
|
if ( m_flTimeLastMapChangeOrPlayerWasConnected <= 0.0f )
|
|
{
|
|
m_flTimeLastMapChangeOrPlayerWasConnected = flNow;
|
|
}
|
|
else
|
|
{
|
|
for( int iPlayerIndex = 1 ; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ )
|
|
{
|
|
player_info_t pi;
|
|
if ( !engine->GetPlayerInfo( iPlayerIndex, &pi ) )
|
|
continue;
|
|
#if defined( REPLAY_ENABLED )
|
|
if ( pi.ishltv || pi.isreplay || pi.fakeplayer )
|
|
#else
|
|
if ( pi.ishltv || pi.fakeplayer )
|
|
#endif
|
|
continue;
|
|
|
|
m_flTimeLastMapChangeOrPlayerWasConnected = flNow;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Check if we should cycle the map because we've been empty
|
|
// for long enough
|
|
if ( mp_mapcycle_empty_timeout_seconds.GetInt() > 0 )
|
|
{
|
|
int iIdleSeconds = (int)( flNow - m_flTimeLastMapChangeOrPlayerWasConnected );
|
|
if ( iIdleSeconds >= mp_mapcycle_empty_timeout_seconds.GetInt() )
|
|
{
|
|
|
|
Log( "Server has been empty for %d seconds on this map, cycling map as per mp_mapcycle_empty_timeout_seconds\n", iIdleSeconds );
|
|
ChangeLevel();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
bool CMultiplayRules::IsDeathmatch( void )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
bool CMultiplayRules::IsCoOp( void )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
bool CMultiplayRules::FShouldSwitchWeapon( CBasePlayer *pPlayer, CBaseCombatWeapon *pWeapon )
|
|
{
|
|
if ( !pPlayer->Weapon_CanSwitchTo( pWeapon ) )
|
|
{
|
|
// Can't switch weapons for some reason.
|
|
return false;
|
|
}
|
|
|
|
if ( !pPlayer->GetActiveWeapon() )
|
|
{
|
|
// Player doesn't have an active item, might as well switch.
|
|
return true;
|
|
}
|
|
|
|
if ( !pWeapon->AllowsAutoSwitchTo() )
|
|
{
|
|
// The given weapon should not be auto switched to from another weapon.
|
|
return false;
|
|
}
|
|
|
|
if ( !pPlayer->GetActiveWeapon()->AllowsAutoSwitchFrom() )
|
|
{
|
|
// The active weapon does not allow autoswitching away from it.
|
|
return false;
|
|
}
|
|
|
|
if ( pWeapon->GetWeight() > pPlayer->GetActiveWeapon()->GetWeight() )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns the weapon in the player's inventory that would be better than
|
|
// the given weapon.
|
|
//-----------------------------------------------------------------------------
|
|
CBaseCombatWeapon *CMultiplayRules::GetNextBestWeapon( CBaseCombatCharacter *pPlayer, CBaseCombatWeapon *pCurrentWeapon )
|
|
{
|
|
CBaseCombatWeapon *pCheck;
|
|
CBaseCombatWeapon *pBest;// this will be used in the event that we don't find a weapon in the same category.
|
|
|
|
int iCurrentWeight = -1;
|
|
int iBestWeight = -1;// no weapon lower than -1 can be autoswitched to
|
|
pBest = NULL;
|
|
|
|
// If I have a weapon, make sure I'm allowed to holster it
|
|
if ( pCurrentWeapon )
|
|
{
|
|
if ( !pCurrentWeapon->AllowsAutoSwitchFrom() || !pCurrentWeapon->CanHolster() )
|
|
{
|
|
// Either this weapon doesn't allow autoswitching away from it or I
|
|
// can't put this weapon away right now, so I can't switch.
|
|
return NULL;
|
|
}
|
|
|
|
iCurrentWeight = pCurrentWeapon->GetWeight();
|
|
}
|
|
|
|
for ( int i = 0 ; i < pPlayer->WeaponCount(); ++i )
|
|
{
|
|
pCheck = pPlayer->GetWeapon( i );
|
|
if ( !pCheck )
|
|
continue;
|
|
|
|
// If we have an active weapon and this weapon doesn't allow autoswitching away
|
|
// from another weapon, skip it.
|
|
if ( pCurrentWeapon && !pCheck->AllowsAutoSwitchTo() )
|
|
continue;
|
|
|
|
if ( pCheck->GetWeight() > -1 && pCheck->GetWeight() == iCurrentWeight && pCheck != pCurrentWeapon )
|
|
{
|
|
// this weapon is from the same category.
|
|
if ( pCheck->HasAnyAmmo() )
|
|
{
|
|
if ( pPlayer->Weapon_CanSwitchTo( pCheck ) )
|
|
{
|
|
return pCheck;
|
|
}
|
|
}
|
|
}
|
|
else if ( pCheck->GetWeight() > iBestWeight && pCheck != pCurrentWeapon )// don't reselect the weapon we're trying to get rid of
|
|
{
|
|
//Msg( "Considering %s\n", STRING( pCheck->GetClassname() );
|
|
// we keep updating the 'best' weapon just in case we can't find a weapon of the same weight
|
|
// that the player was using. This will end up leaving the player with his heaviest-weighted
|
|
// weapon.
|
|
if ( pCheck->HasAnyAmmo() )
|
|
{
|
|
// if this weapon is useable, flag it as the best
|
|
iBestWeight = pCheck->GetWeight();
|
|
pBest = pCheck;
|
|
}
|
|
}
|
|
}
|
|
|
|
// if we make it here, we've checked all the weapons and found no useable
|
|
// weapon in the same catagory as the current weapon.
|
|
|
|
// if pBest is null, we didn't find ANYTHING. Shouldn't be possible- should always
|
|
// at least get the crowbar, but ya never know.
|
|
return pBest;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CMultiplayRules::SwitchToNextBestWeapon( CBaseCombatCharacter *pPlayer, CBaseCombatWeapon *pCurrentWeapon )
|
|
{
|
|
CBaseCombatWeapon *pWeapon = GetNextBestWeapon( pPlayer, pCurrentWeapon );
|
|
|
|
if ( pWeapon != NULL )
|
|
return pPlayer->Weapon_Switch( pWeapon );
|
|
|
|
return false;
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
bool CMultiplayRules::ClientConnected( edict_t *pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen )
|
|
{
|
|
GetVoiceGameMgr()->ClientConnected( pEntity );
|
|
return true;
|
|
}
|
|
|
|
void CMultiplayRules::InitHUD( CBasePlayer *pl )
|
|
{
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
void CMultiplayRules::ClientDisconnected( edict_t *pClient )
|
|
{
|
|
if ( pClient )
|
|
{
|
|
CBasePlayer *pPlayer = (CBasePlayer *)CBaseEntity::Instance( pClient );
|
|
|
|
if ( pPlayer )
|
|
{
|
|
FireTargets( "game_playerleave", pPlayer, pPlayer, USE_TOGGLE, 0 );
|
|
|
|
pPlayer->RemoveAllItems( true );// destroy all of the players weapons and items
|
|
|
|
// Kill off view model entities
|
|
pPlayer->DestroyViewModels();
|
|
|
|
pPlayer->SetConnected( PlayerDisconnected );
|
|
}
|
|
}
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
float CMultiplayRules::FlPlayerFallDamage( CBasePlayer *pPlayer )
|
|
{
|
|
int iFallDamage = (int)falldamage.GetFloat();
|
|
|
|
switch ( iFallDamage )
|
|
{
|
|
case 1://progressive
|
|
pPlayer->m_Local.m_flFallVelocity -= PLAYER_MAX_SAFE_FALL_SPEED;
|
|
return pPlayer->m_Local.m_flFallVelocity * DAMAGE_FOR_FALL_SPEED;
|
|
break;
|
|
default:
|
|
case 0:// fixed
|
|
return 10;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
bool CMultiplayRules::AllowDamage( CBaseEntity *pVictim, const CTakeDamageInfo &info )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
bool CMultiplayRules::FPlayerCanTakeDamage( CBasePlayer *pPlayer, CBaseEntity *pAttacker, const CTakeDamageInfo &info )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
void CMultiplayRules::PlayerThink( CBasePlayer *pPlayer )
|
|
{
|
|
if ( g_fGameOver )
|
|
{
|
|
// clear attack/use commands from player
|
|
pPlayer->m_afButtonPressed = 0;
|
|
pPlayer->m_nButtons = 0;
|
|
pPlayer->m_afButtonReleased = 0;
|
|
}
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
void CMultiplayRules::PlayerSpawn( CBasePlayer *pPlayer )
|
|
{
|
|
bool addDefault;
|
|
CBaseEntity *pWeaponEntity = NULL;
|
|
|
|
pPlayer->EquipSuit();
|
|
|
|
addDefault = true;
|
|
|
|
while ( (pWeaponEntity = gEntList.FindEntityByClassname( pWeaponEntity, "game_player_equip" )) != NULL)
|
|
{
|
|
pWeaponEntity->Touch( pPlayer );
|
|
addDefault = false;
|
|
}
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
bool CMultiplayRules::FPlayerCanRespawn( CBasePlayer *pPlayer )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
float CMultiplayRules::FlPlayerSpawnTime( CBasePlayer *pPlayer )
|
|
{
|
|
return gpGlobals->curtime;//now!
|
|
}
|
|
|
|
bool CMultiplayRules::AllowAutoTargetCrosshair( void )
|
|
{
|
|
return ( aimcrosshair.GetInt() != 0 );
|
|
}
|
|
|
|
//=========================================================
|
|
// IPointsForKill - how many points awarded to anyone
|
|
// that kills this player?
|
|
//=========================================================
|
|
int CMultiplayRules::IPointsForKill( CBasePlayer *pAttacker, CBasePlayer *pKilled )
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CBasePlayer *CMultiplayRules::GetDeathScorer( CBaseEntity *pKiller, CBaseEntity *pInflictor )
|
|
{
|
|
if ( pKiller)
|
|
{
|
|
if ( pKiller->Classify() == CLASS_PLAYER )
|
|
return (CBasePlayer*)pKiller;
|
|
|
|
// Killing entity might be specifying a scorer player
|
|
IScorer *pScorerInterface = dynamic_cast<IScorer*>( pKiller );
|
|
if ( pScorerInterface )
|
|
{
|
|
CBasePlayer *pPlayer = pScorerInterface->GetScorer();
|
|
if ( pPlayer )
|
|
return pPlayer;
|
|
}
|
|
|
|
// Inflicting entity might be specifying a scoring player
|
|
pScorerInterface = dynamic_cast<IScorer*>( pInflictor );
|
|
if ( pScorerInterface )
|
|
{
|
|
CBasePlayer *pPlayer = pScorerInterface->GetScorer();
|
|
if ( pPlayer )
|
|
return pPlayer;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns player who should receive credit for kill
|
|
//-----------------------------------------------------------------------------
|
|
CBasePlayer *CMultiplayRules::GetDeathScorer( CBaseEntity *pKiller, CBaseEntity *pInflictor, CBaseEntity *pVictim )
|
|
{
|
|
// if this method not overridden by subclass, just call our default implementation
|
|
return GetDeathScorer( pKiller, pInflictor );
|
|
}
|
|
|
|
//=========================================================
|
|
// PlayerKilled - someone/something killed this player
|
|
//=========================================================
|
|
void CMultiplayRules::PlayerKilled( CBasePlayer *pVictim, const CTakeDamageInfo &info )
|
|
{
|
|
DeathNotice( pVictim, info );
|
|
|
|
// Find the killer & the scorer
|
|
CBaseEntity *pInflictor = info.GetInflictor();
|
|
CBaseEntity *pKiller = info.GetAttacker();
|
|
CBasePlayer *pScorer = GetDeathScorer( pKiller, pInflictor, pVictim );
|
|
|
|
pVictim->IncrementDeathCount( 1 );
|
|
|
|
// 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 );
|
|
|
|
// Did the player kill himself?
|
|
if ( pVictim == pScorer )
|
|
{
|
|
if ( UseSuicidePenalty() )
|
|
{
|
|
// Players lose a frag for killing themselves
|
|
pVictim->IncrementFragCount( -1 );
|
|
}
|
|
}
|
|
else if ( pScorer )
|
|
{
|
|
// if a player dies in a deathmatch game and the killer is a client, award the killer some points
|
|
pScorer->IncrementFragCount( IPointsForKill( pScorer, pVictim ) );
|
|
|
|
// Allow the scorer to immediately paint a decal
|
|
pScorer->AllowImmediateDecalPainting();
|
|
|
|
// dvsents2: uncomment when removing all FireTargets
|
|
//variant_t value;
|
|
//g_EventQueue.AddEvent( "game_playerkill", "Use", value, 0, pScorer, pScorer );
|
|
FireTargets( "game_playerkill", pScorer, pScorer, USE_TOGGLE, 0 );
|
|
}
|
|
else
|
|
{
|
|
if ( UseSuicidePenalty() )
|
|
{
|
|
// Players lose a frag for letting the world kill them
|
|
pVictim->IncrementFragCount( -1 );
|
|
}
|
|
}
|
|
}
|
|
|
|
//=========================================================
|
|
// Deathnotice.
|
|
//=========================================================
|
|
void CMultiplayRules::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, pVictim );
|
|
|
|
// Custom damage type?
|
|
if ( info.GetDamageCustom() )
|
|
{
|
|
killer_weapon_name = GetDamageCustomString( info );
|
|
if ( pScorer )
|
|
{
|
|
killer_ID = pScorer->GetUserID();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Is the killer a client?
|
|
if ( pScorer )
|
|
{
|
|
killer_ID = pScorer->GetUserID();
|
|
|
|
if ( pInflictor )
|
|
{
|
|
if ( pInflictor == pScorer )
|
|
{
|
|
// If the inflictor is the killer, then it must be their current weapon doing the damage
|
|
if ( pScorer->GetActiveWeapon() )
|
|
{
|
|
#ifdef HL1MP_DLL
|
|
killer_weapon_name = pScorer->GetActiveWeapon()->GetClassname();
|
|
#else
|
|
killer_weapon_name = pScorer->GetActiveWeapon()->GetDeathNoticeName();
|
|
#endif
|
|
}
|
|
}
|
|
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_", 4 ) == 0 )
|
|
{
|
|
killer_weapon_name += 4;
|
|
}
|
|
else if ( strncmp( killer_weapon_name, "func_", 5 ) == 0 )
|
|
{
|
|
killer_weapon_name += 5;
|
|
}
|
|
}
|
|
|
|
IGameEvent * event = gameeventmanager->CreateEvent( "player_death" );
|
|
if ( event )
|
|
{
|
|
event->SetInt("userid", pVictim->GetUserID() );
|
|
event->SetInt("attacker", killer_ID );
|
|
event->SetInt("customkill", info.GetDamageCustom() );
|
|
event->SetInt("priority", 7 ); // HLTV event priority, not transmitted
|
|
#ifdef HL1MP_DLL
|
|
event->SetString("weapon", killer_weapon_name );
|
|
#endif
|
|
gameeventmanager->FireEvent( event );
|
|
}
|
|
|
|
}
|
|
|
|
//=========================================================
|
|
// FlWeaponRespawnTime - what is the time in the future
|
|
// at which this weapon may spawn?
|
|
//=========================================================
|
|
float CMultiplayRules::FlWeaponRespawnTime( CBaseCombatWeapon *pWeapon )
|
|
{
|
|
if ( weaponstay.GetInt() > 0 )
|
|
{
|
|
// make sure it's only certain weapons
|
|
if ( !(pWeapon->GetWeaponFlags() & ITEM_FLAG_LIMITINWORLD) )
|
|
{
|
|
return gpGlobals->curtime + 0; // weapon respawns almost instantly
|
|
}
|
|
}
|
|
|
|
return gpGlobals->curtime + WEAPON_RESPAWN_TIME;
|
|
}
|
|
|
|
// when we are within this close to running out of entities, items
|
|
// marked with the ITEM_FLAG_LIMITINWORLD will delay their respawn
|
|
#define ENTITY_INTOLERANCE 100
|
|
|
|
//=========================================================
|
|
// FlWeaponRespawnTime - Returns 0 if the weapon can respawn
|
|
// now, otherwise it returns the time at which it can try
|
|
// to spawn again.
|
|
//=========================================================
|
|
float CMultiplayRules::FlWeaponTryRespawn( CBaseCombatWeapon *pWeapon )
|
|
{
|
|
if ( pWeapon && (pWeapon->GetWeaponFlags() & ITEM_FLAG_LIMITINWORLD) )
|
|
{
|
|
if ( gEntList.NumberOfEntities() < (gpGlobals->maxEntities - ENTITY_INTOLERANCE) )
|
|
return 0;
|
|
|
|
// we're past the entity tolerance level, so delay the respawn
|
|
return FlWeaponRespawnTime( pWeapon );
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//=========================================================
|
|
// VecWeaponRespawnSpot - where should this weapon spawn?
|
|
// Some game variations may choose to randomize spawn locations
|
|
//=========================================================
|
|
Vector CMultiplayRules::VecWeaponRespawnSpot( CBaseCombatWeapon *pWeapon )
|
|
{
|
|
return pWeapon->GetAbsOrigin();
|
|
}
|
|
|
|
//=========================================================
|
|
// WeaponShouldRespawn - any conditions inhibiting the
|
|
// respawning of this weapon?
|
|
//=========================================================
|
|
int CMultiplayRules::WeaponShouldRespawn( CBaseCombatWeapon *pWeapon )
|
|
{
|
|
if ( pWeapon->HasSpawnFlags( SF_NORESPAWN ) )
|
|
{
|
|
return GR_WEAPON_RESPAWN_NO;
|
|
}
|
|
|
|
return GR_WEAPON_RESPAWN_YES;
|
|
}
|
|
|
|
//=========================================================
|
|
// CanHaveWeapon - returns false if the player is not allowed
|
|
// to pick up this weapon
|
|
//=========================================================
|
|
bool CMultiplayRules::CanHavePlayerItem( CBasePlayer *pPlayer, CBaseCombatWeapon *pItem )
|
|
{
|
|
if ( weaponstay.GetInt() > 0 )
|
|
{
|
|
if ( pItem->GetWeaponFlags() & ITEM_FLAG_LIMITINWORLD )
|
|
return BaseClass::CanHavePlayerItem( pPlayer, pItem );
|
|
|
|
// check if the player already has this weapon
|
|
for ( int i = 0 ; i < pPlayer->WeaponCount() ; i++ )
|
|
{
|
|
if ( pPlayer->GetWeapon(i) == pItem )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return BaseClass::CanHavePlayerItem( pPlayer, pItem );
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
bool CMultiplayRules::CanHaveItem( CBasePlayer *pPlayer, CItem *pItem )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
void CMultiplayRules::PlayerGotItem( CBasePlayer *pPlayer, CItem *pItem )
|
|
{
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
int CMultiplayRules::ItemShouldRespawn( CItem *pItem )
|
|
{
|
|
if ( pItem->HasSpawnFlags( SF_NORESPAWN ) )
|
|
{
|
|
return GR_ITEM_RESPAWN_NO;
|
|
}
|
|
|
|
return GR_ITEM_RESPAWN_YES;
|
|
}
|
|
|
|
|
|
//=========================================================
|
|
// At what time in the future may this Item respawn?
|
|
//=========================================================
|
|
float CMultiplayRules::FlItemRespawnTime( CItem *pItem )
|
|
{
|
|
return gpGlobals->curtime + ITEM_RESPAWN_TIME;
|
|
}
|
|
|
|
//=========================================================
|
|
// Where should this item respawn?
|
|
// Some game variations may choose to randomize spawn locations
|
|
//=========================================================
|
|
Vector CMultiplayRules::VecItemRespawnSpot( CItem *pItem )
|
|
{
|
|
return pItem->GetAbsOrigin();
|
|
}
|
|
|
|
//=========================================================
|
|
// What angles should this item use to respawn?
|
|
//=========================================================
|
|
QAngle CMultiplayRules::VecItemRespawnAngles( CItem *pItem )
|
|
{
|
|
return pItem->GetAbsAngles();
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
void CMultiplayRules::PlayerGotAmmo( CBaseCombatCharacter *pPlayer, char *szName, int iCount )
|
|
{
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
bool CMultiplayRules::IsAllowedToSpawn( CBaseEntity *pEntity )
|
|
{
|
|
// if ( pEntity->GetFlags() & FL_NPC )
|
|
// return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
float CMultiplayRules::FlHealthChargerRechargeTime( void )
|
|
{
|
|
return 60;
|
|
}
|
|
|
|
|
|
float CMultiplayRules::FlHEVChargerRechargeTime( void )
|
|
{
|
|
return 30;
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
int CMultiplayRules::DeadPlayerWeapons( CBasePlayer *pPlayer )
|
|
{
|
|
return GR_PLR_DROP_GUN_ACTIVE;
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
int CMultiplayRules::DeadPlayerAmmo( CBasePlayer *pPlayer )
|
|
{
|
|
return GR_PLR_DROP_AMMO_ACTIVE;
|
|
}
|
|
|
|
CBaseEntity *CMultiplayRules::GetPlayerSpawnSpot( CBasePlayer *pPlayer )
|
|
{
|
|
CBaseEntity *pentSpawnSpot = BaseClass::GetPlayerSpawnSpot( pPlayer );
|
|
|
|
//!! replace this with an Event
|
|
/*
|
|
if ( IsMultiplayer() && pentSpawnSpot->m_target )
|
|
{
|
|
FireTargets( STRING(pentSpawnSpot->m_target), pPlayer, pPlayer, USE_TOGGLE, 0 ); // dvsents2: what is this code supposed to do?
|
|
}
|
|
*/
|
|
|
|
return pentSpawnSpot;
|
|
}
|
|
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
bool CMultiplayRules::PlayerCanHearChat( CBasePlayer *pListener, CBasePlayer *pSpeaker )
|
|
{
|
|
return ( PlayerRelationship( pListener, pSpeaker ) == GR_TEAMMATE );
|
|
}
|
|
|
|
int CMultiplayRules::PlayerRelationship( CBaseEntity *pPlayer, CBaseEntity *pTarget )
|
|
{
|
|
// half life deathmatch has only enemies
|
|
return GR_NOTTEAMMATE;
|
|
}
|
|
|
|
bool CMultiplayRules::PlayFootstepSounds( CBasePlayer *pl )
|
|
{
|
|
if ( footsteps.GetInt() == 0 )
|
|
return false;
|
|
|
|
if ( pl->IsOnLadder() || pl->GetAbsVelocity().Length2D() > 220 )
|
|
return true; // only make step sounds in multiplayer if the player is moving fast enough
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CMultiplayRules::FAllowFlashlight( void )
|
|
{
|
|
return flashlight.GetInt() != 0;
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
bool CMultiplayRules::FAllowNPCs( void )
|
|
{
|
|
return true; // E3 hack
|
|
return ( allowNPCs.GetInt() != 0 );
|
|
}
|
|
|
|
//=========================================================
|
|
//======== CMultiplayRules private functions ===========
|
|
|
|
void CMultiplayRules::GoToIntermission( void )
|
|
{
|
|
if ( g_fGameOver )
|
|
return;
|
|
|
|
g_fGameOver = true;
|
|
|
|
float flWaitTime = mp_chattime.GetInt();
|
|
|
|
if ( tv_delaymapchange.GetBool() )
|
|
{
|
|
if ( HLTVDirector()->IsActive() )
|
|
flWaitTime = MAX( flWaitTime, HLTVDirector()->GetDelay() );
|
|
}
|
|
|
|
m_flIntermissionEndTime = gpGlobals->curtime + flWaitTime;
|
|
|
|
for ( int i = 1; i <= MAX_PLAYERS; i++ )
|
|
{
|
|
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
|
|
|
|
if ( !pPlayer )
|
|
continue;
|
|
|
|
pPlayer->ShowViewPortPanel( PANEL_SCOREBOARD );
|
|
}
|
|
}
|
|
|
|
// Strip ' ' and '\n' characters from string.
|
|
static void StripWhitespaceChars( char *szBuffer )
|
|
{
|
|
char *szOut = szBuffer;
|
|
|
|
for ( char *szIn = szOut; *szIn; szIn++ )
|
|
{
|
|
if ( *szIn != ' ' && *szIn != '\r' )
|
|
*szOut++ = *szIn;
|
|
}
|
|
*szOut = '\0';
|
|
}
|
|
|
|
void CMultiplayRules::GetNextLevelName( char *pszNextMap, int bufsize, bool bRandom /* = false */ )
|
|
{
|
|
char mapcfile[MAX_PATH];
|
|
DetermineMapCycleFilename( mapcfile, sizeof(mapcfile), false );
|
|
|
|
// Check the time of the mapcycle file and re-populate the list of level names if the file has been modified
|
|
const int nMapCycleTimeStamp = filesystem->GetPathTime( mapcfile, "GAME" );
|
|
|
|
if ( 0 == nMapCycleTimeStamp )
|
|
{
|
|
// Map cycle file does not exist, make a list containing only the current map
|
|
char *szCurrentMapName = new char[MAX_MAP_NAME];
|
|
Q_strncpy( szCurrentMapName, STRING(gpGlobals->mapname), MAX_MAP_NAME );
|
|
m_MapList.AddToTail( szCurrentMapName );
|
|
}
|
|
else
|
|
{
|
|
// If map cycle file has changed or this is the first time through ...
|
|
if ( m_nMapCycleTimeStamp != nMapCycleTimeStamp )
|
|
{
|
|
// Reload
|
|
LoadMapCycleFile();
|
|
}
|
|
}
|
|
|
|
// If somehow we have no maps in the list then add the current one
|
|
if ( 0 == m_MapList.Count() )
|
|
{
|
|
char *szDefaultMapName = new char[MAX_MAP_NAME];
|
|
Q_strncpy( szDefaultMapName, STRING(gpGlobals->mapname), MAX_MAP_NAME );
|
|
m_MapList.AddToTail( szDefaultMapName );
|
|
}
|
|
|
|
if ( bRandom )
|
|
{
|
|
m_nMapCycleindex = RandomInt( 0, m_MapList.Count() - 1 );
|
|
}
|
|
|
|
// Here's the return value
|
|
Q_strncpy( pszNextMap, m_MapList[m_nMapCycleindex], bufsize);
|
|
}
|
|
|
|
void CMultiplayRules::DetermineMapCycleFilename( char *pszResult, int nSizeResult, bool bForceSpew )
|
|
{
|
|
static char szLastResult[ MAX_PATH ];
|
|
|
|
const char *pszVar = mapcyclefile.GetString();
|
|
if ( *pszVar == '\0' )
|
|
{
|
|
if ( bForceSpew || V_stricmp( szLastResult, "__novar") )
|
|
{
|
|
Msg( "mapcyclefile convar not set.\n" );
|
|
V_strcpy_safe( szLastResult, "__novar" );
|
|
}
|
|
*pszResult = '\0';
|
|
return;
|
|
}
|
|
|
|
char szRecommendedName[ MAX_PATH ];
|
|
V_sprintf_safe( szRecommendedName, "cfg/%s", pszVar );
|
|
|
|
// First, look for a mapcycle file in the cfg directory, which is preferred
|
|
V_strncpy( pszResult, szRecommendedName, nSizeResult );
|
|
if ( filesystem->FileExists( pszResult, "GAME" ) )
|
|
{
|
|
if ( bForceSpew || V_stricmp( szLastResult, pszResult) )
|
|
{
|
|
Msg( "Using map cycle file '%s'.\n", pszResult );
|
|
V_strcpy_safe( szLastResult, pszResult );
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Nope? Try the root.
|
|
V_strncpy( pszResult, pszVar, nSizeResult );
|
|
if ( filesystem->FileExists( pszResult, "GAME" ) )
|
|
{
|
|
if ( bForceSpew || V_stricmp( szLastResult, pszResult) )
|
|
{
|
|
Msg( "Using map cycle file '%s'. ('%s' was not found.)\n", pszResult, szRecommendedName );
|
|
V_strcpy_safe( szLastResult, pszResult );
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Nope? Use the default.
|
|
if ( !V_stricmp( pszVar, "mapcycle.txt" ) )
|
|
{
|
|
V_strncpy( pszResult, "cfg/mapcycle_default.txt", nSizeResult );
|
|
if ( filesystem->FileExists( pszResult, "GAME" ) )
|
|
{
|
|
if ( bForceSpew || V_stricmp( szLastResult, pszResult) )
|
|
{
|
|
Msg( "Using map cycle file '%s'. ('%s' was not found.)\n", pszResult, szRecommendedName );
|
|
V_strcpy_safe( szLastResult, pszResult );
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Failed
|
|
*pszResult = '\0';
|
|
if ( bForceSpew || V_stricmp( szLastResult, "__notfound") )
|
|
{
|
|
Msg( "Map cycle file '%s' was not found.\n", szRecommendedName );
|
|
V_strcpy_safe( szLastResult, "__notfound" );
|
|
}
|
|
}
|
|
|
|
void CMultiplayRules::LoadMapCycleFileIntoVector( const char *pszMapCycleFile, CUtlVector<char *> &mapList )
|
|
{
|
|
CMultiplayRules::RawLoadMapCycleFileIntoVector( pszMapCycleFile, mapList );
|
|
}
|
|
|
|
void CMultiplayRules::RawLoadMapCycleFileIntoVector( const char *pszMapCycleFile, CUtlVector<char *> &mapList )
|
|
{
|
|
CUtlBuffer buf;
|
|
if ( !filesystem->ReadFile( pszMapCycleFile, "GAME", buf ) )
|
|
return;
|
|
buf.PutChar( 0 );
|
|
V_SplitString( (char*)buf.Base(), "\n", mapList );
|
|
|
|
for ( int i = 0; i < mapList.Count(); i++ )
|
|
{
|
|
bool bIgnore = false;
|
|
|
|
// Strip out ' ' and '\r' chars.
|
|
StripWhitespaceChars( mapList[i] );
|
|
|
|
if ( !Q_strncmp( mapList[i], "//", 2 ) || mapList[i][0] == '\0' )
|
|
{
|
|
bIgnore = true;
|
|
}
|
|
|
|
if ( bIgnore )
|
|
{
|
|
delete [] mapList[i];
|
|
mapList.Remove( i );
|
|
--i;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CMultiplayRules::FreeMapCycleFileVector( CUtlVector<char *> &mapList )
|
|
{
|
|
// Clear out existing map list. Not using Purge() or PurgeAndDeleteAll() because they won't delete [] each element.
|
|
for ( int i = 0; i < mapList.Count(); i++ )
|
|
{
|
|
delete [] mapList[i];
|
|
}
|
|
|
|
mapList.RemoveAll();
|
|
}
|
|
|
|
bool CMultiplayRules::IsManualMapChangeOkay( const char **pszReason )
|
|
{
|
|
if ( HLTVDirector()->IsActive() && ( HLTVDirector()->GetDelay() >= HLTV_MIN_DIRECTOR_DELAY ) )
|
|
{
|
|
if ( tv_delaymapchange.GetBool() && tv_delaymapchange_protect.GetBool() )
|
|
{
|
|
float flLastEvent = GetLastMajorEventTime();
|
|
if ( flLastEvent > -1 )
|
|
{
|
|
if ( flLastEvent > ( gpGlobals->curtime - ( HLTVDirector()->GetDelay() + 3 ) ) ) // +3 second delay to prevent instant change after a major event
|
|
{
|
|
*pszReason = "\n***WARNING*** Map change blocked. HLTV is broadcasting and has not caught up to the last major game event yet.\nYou can disable this check by setting the value of the server convar \"tv_delaymapchange_protect\" to 0.\n";
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CMultiplayRules::IsMapInMapCycle( const char *pszName )
|
|
{
|
|
for ( int i = 0; i < m_MapList.Count(); i++ )
|
|
{
|
|
if ( V_stricmp( pszName, m_MapList[i] ) == 0 )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void CMultiplayRules::ChangeLevel( void )
|
|
{
|
|
char szNextMap[MAX_MAP_NAME];
|
|
|
|
if ( nextlevel.GetString() && *nextlevel.GetString() )
|
|
{
|
|
Q_strncpy( szNextMap, nextlevel.GetString(), sizeof( szNextMap ) );
|
|
}
|
|
else
|
|
{
|
|
GetNextLevelName( szNextMap, sizeof(szNextMap) );
|
|
IncrementMapCycleIndex();
|
|
}
|
|
|
|
ChangeLevelToMap( szNextMap );
|
|
}
|
|
|
|
void CMultiplayRules::LoadMapCycleFile( void )
|
|
{
|
|
int nOldCycleIndex = m_nMapCycleindex;
|
|
m_nMapCycleindex = 0;
|
|
|
|
char mapcfile[MAX_PATH];
|
|
DetermineMapCycleFilename( mapcfile, sizeof(mapcfile), false );
|
|
|
|
FreeMapCycleFileVector( m_MapList );
|
|
|
|
const int nMapCycleTimeStamp = filesystem->GetPathTime( mapcfile, "GAME" );
|
|
m_nMapCycleTimeStamp = nMapCycleTimeStamp;
|
|
|
|
// Repopulate map list from mapcycle file
|
|
LoadMapCycleFileIntoVector( mapcfile, m_MapList );
|
|
|
|
// Load server's mapcycle into network string table for client-side voting
|
|
if ( g_pStringTableServerMapCycle )
|
|
{
|
|
CUtlString sFileList;
|
|
for ( int i = 0; i < m_MapList.Count(); i++ )
|
|
{
|
|
sFileList += m_MapList[i];
|
|
sFileList += '\n';
|
|
}
|
|
|
|
g_pStringTableServerMapCycle->AddString( CBaseEntity::IsServer(), "ServerMapCycle", sFileList.Length() + 1, sFileList.String() );
|
|
}
|
|
|
|
#if defined ( TF_DLL ) || defined ( TF_CLIENT_DLL )
|
|
if ( g_pStringTableServerPopFiles )
|
|
{
|
|
// Search for all pop files that are prefixed with the current map name
|
|
CUtlString sFileList;
|
|
|
|
CUtlVector< CUtlString > defaultPopFiles;
|
|
CPopulationManager::FindDefaultPopulationFileShortNames( defaultPopFiles );
|
|
|
|
FOR_EACH_VEC( defaultPopFiles, idx )
|
|
{
|
|
sFileList += defaultPopFiles[ idx ];
|
|
sFileList += "\n";
|
|
}
|
|
|
|
if ( sFileList.Length() > 0 )
|
|
{
|
|
g_pStringTableServerPopFiles->AddString( CBaseEntity::IsServer(), "ServerPopFiles", sFileList.Length() + 1, sFileList.String() );
|
|
}
|
|
}
|
|
|
|
if ( g_pStringTableServerMapCycleMvM )
|
|
{
|
|
ConVarRef tf_mvm_missioncyclefile( "tf_mvm_missioncyclefile" );
|
|
KeyValues *pKV = new KeyValues( tf_mvm_missioncyclefile.GetString() );
|
|
if ( pKV->LoadFromFile( g_pFullFileSystem, tf_mvm_missioncyclefile.GetString(), "MOD" ) )
|
|
{
|
|
CUtlVector<CUtlString> mapList;
|
|
|
|
// Parse the maps and send a list to each client for vote options
|
|
int iMaxCat = pKV->GetInt( "categories", 0 );
|
|
for ( int iCat = 1; iCat <= iMaxCat; iCat++ )
|
|
{
|
|
KeyValues *pCategory = pKV->FindKey( UTIL_VarArgs( "%d", iCat ), false );
|
|
if ( pCategory )
|
|
{
|
|
int iMapCount = pCategory->GetInt( "count", 0 );
|
|
for ( int iMap = 1; iMap <= iMapCount; ++iMap )
|
|
{
|
|
KeyValues *pMission = pCategory->FindKey( UTIL_VarArgs( "%d", iMap ), false );
|
|
if ( pMission )
|
|
{
|
|
const char *pszMap = pMission->GetString( "map", "" );
|
|
int iIdx = mapList.Find( pszMap );
|
|
if ( !mapList.IsValidIndex( iIdx ) )
|
|
{
|
|
mapList.AddToTail( pszMap );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( mapList.Count() )
|
|
{
|
|
CUtlString sFileList;
|
|
for ( int i = 0; i < mapList.Count(); i++ )
|
|
{
|
|
sFileList += mapList[i];
|
|
sFileList += '\n';
|
|
}
|
|
|
|
g_pStringTableServerMapCycleMvM->AddString( CBaseEntity::IsServer(), "ServerMapCycleMvM", sFileList.Length() + 1, sFileList.String() );
|
|
}
|
|
|
|
pKV->deleteThis();
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// If the current map is in the same location in the new map cycle, keep that index. This gives better behavior
|
|
// when reloading a map cycle that has the current map in it multiple times.
|
|
int nOldPreviousMap = ( nOldCycleIndex == 0 ) ? ( m_MapList.Count() - 1 ) : ( nOldCycleIndex - 1 );
|
|
if ( nOldCycleIndex >= 0 && nOldCycleIndex < m_MapList.Count() &&
|
|
nOldPreviousMap >= 0 && nOldPreviousMap < m_MapList.Count() &&
|
|
V_strcmp( STRING( gpGlobals->mapname ), m_MapList[ nOldPreviousMap ] ) == 0 )
|
|
{
|
|
// The old index is still valid, and falls after our current map in the new cycle, use it
|
|
m_nMapCycleindex = nOldCycleIndex;
|
|
}
|
|
else
|
|
{
|
|
// Otherwise, if the current map selection is in the list, set m_nMapCycleindex to the map that follows it.
|
|
for ( int i = 0; i < m_MapList.Count(); i++ )
|
|
{
|
|
if ( V_strcmp( STRING( gpGlobals->mapname ), m_MapList[i] ) == 0 )
|
|
{
|
|
m_nMapCycleindex = i;
|
|
IncrementMapCycleIndex();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CMultiplayRules::ChangeLevelToMap( const char *pszMap )
|
|
{
|
|
g_fGameOver = true;
|
|
m_flTimeLastMapChangeOrPlayerWasConnected = 0.0f;
|
|
Msg( "CHANGE LEVEL: %s\n", pszMap );
|
|
engine->ChangeLevel( pszMap, NULL );
|
|
}
|
|
|
|
|
|
#endif
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Shared script resource of voice menu commands and hud strings
|
|
//-----------------------------------------------------------------------------
|
|
void CMultiplayRules::LoadVoiceCommandScript( void )
|
|
{
|
|
KeyValues *pKV = new KeyValues( "VoiceCommands" );
|
|
|
|
if ( pKV->LoadFromFile( filesystem, "scripts/voicecommands.txt", "GAME" ) )
|
|
{
|
|
for ( KeyValues *menu = pKV->GetFirstSubKey(); menu != NULL; menu = menu->GetNextKey() )
|
|
{
|
|
int iMenuIndex = m_VoiceCommandMenus.AddToTail();
|
|
|
|
int iNumItems = 0;
|
|
|
|
// for each subkey of this menu, add a menu item
|
|
for ( KeyValues *menuitem = menu->GetFirstSubKey(); menuitem != NULL; menuitem = menuitem->GetNextKey() )
|
|
{
|
|
iNumItems++;
|
|
|
|
if ( iNumItems > 9 )
|
|
{
|
|
Warning( "Trying to load more than 9 menu items in voicecommands.txt, extras ignored" );
|
|
continue;
|
|
}
|
|
|
|
VoiceCommandMenuItem_t item;
|
|
|
|
#ifndef CLIENT_DLL
|
|
int iConcept = GetMPConceptIndexFromString( menuitem->GetString( "concept", "" ) );
|
|
if ( iConcept == MP_CONCEPT_NONE )
|
|
{
|
|
Warning( "Voicecommand script attempting to use unknown concept. Need to define new concepts in code. ( %s )\n", menuitem->GetString( "concept", "" ) );
|
|
}
|
|
item.m_iConcept = iConcept;
|
|
|
|
item.m_bShowSubtitle = ( menuitem->GetInt( "show_subtitle", 0 ) > 0 );
|
|
item.m_bDistanceBasedSubtitle = ( menuitem->GetInt( "distance_check_subtitle", 0 ) > 0 );
|
|
|
|
Q_strncpy( item.m_szGestureActivity, menuitem->GetString( "activity", "" ), sizeof( item.m_szGestureActivity ) );
|
|
#else
|
|
Q_strncpy( item.m_szSubtitle, menuitem->GetString( "subtitle", "" ), MAX_VOICE_COMMAND_SUBTITLE );
|
|
Q_strncpy( item.m_szMenuLabel, menuitem->GetString( "menu_label", "" ), MAX_VOICE_COMMAND_SUBTITLE );
|
|
|
|
#endif
|
|
m_VoiceCommandMenus.Element( iMenuIndex ).AddToTail( item );
|
|
}
|
|
}
|
|
}
|
|
|
|
pKV->deleteThis();
|
|
}
|
|
|
|
#ifndef CLIENT_DLL
|
|
|
|
void CMultiplayRules::SkipNextMapInCycle()
|
|
{
|
|
char szSkippedMap[MAX_MAP_NAME];
|
|
char szNextMap[MAX_MAP_NAME];
|
|
|
|
GetNextLevelName( szSkippedMap, sizeof( szSkippedMap ) );
|
|
IncrementMapCycleIndex();
|
|
GetNextLevelName( szNextMap, sizeof( szNextMap ) );
|
|
|
|
Msg( "Skipping: %s\tNext map: %s\n", szSkippedMap, szNextMap );
|
|
|
|
if ( nextlevel.GetString() && *nextlevel.GetString() )
|
|
{
|
|
Msg( "Warning! \"nextlevel\" is set to \"%s\" and will override the next map to be played.\n", nextlevel.GetString() );
|
|
}
|
|
}
|
|
|
|
void CMultiplayRules::IncrementMapCycleIndex()
|
|
{
|
|
// Reset index if we've passed the end of the map list
|
|
if ( ++m_nMapCycleindex >= m_MapList.Count() )
|
|
{
|
|
m_nMapCycleindex = 0;
|
|
}
|
|
}
|
|
|
|
bool CMultiplayRules::ClientCommand( CBaseEntity *pEdict, const CCommand &args )
|
|
{
|
|
CBasePlayer *pPlayer = ToBasePlayer( pEdict );
|
|
|
|
const char *pcmd = args[0];
|
|
if ( FStrEq( pcmd, "voicemenu" ) )
|
|
{
|
|
if ( args.ArgC() < 3 )
|
|
return true;
|
|
|
|
CBaseMultiplayerPlayer *pMultiPlayerPlayer = dynamic_cast< CBaseMultiplayerPlayer * >( pPlayer );
|
|
|
|
if ( pMultiPlayerPlayer )
|
|
{
|
|
int iMenu = atoi( args[1] );
|
|
int iItem = atoi( args[2] );
|
|
|
|
VoiceCommand( pMultiPlayerPlayer, iMenu, iItem );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return BaseClass::ClientCommand( pEdict, args );
|
|
}
|
|
|
|
void CMultiplayRules::ClientCommandKeyValues( edict_t *pEntity, KeyValues *pKeyValues )
|
|
{
|
|
CBaseMultiplayerPlayer *pPlayer = dynamic_cast< CBaseMultiplayerPlayer * >( CBaseEntity::Instance( pEntity ) );
|
|
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
char const *pszCommand = pKeyValues->GetName();
|
|
if ( pszCommand && pszCommand[0] )
|
|
{
|
|
if ( FStrEq( pszCommand, "AchievementEarned" ) )
|
|
{
|
|
if ( pPlayer->ShouldAnnounceAchievement() )
|
|
{
|
|
int nAchievementID = pKeyValues->GetInt( "achievementID" );
|
|
|
|
IGameEvent * event = gameeventmanager->CreateEvent( "achievement_earned" );
|
|
if ( event )
|
|
{
|
|
event->SetInt( "player", pPlayer->entindex() );
|
|
event->SetInt( "achievement", nAchievementID );
|
|
gameeventmanager->FireEvent( event );
|
|
}
|
|
|
|
pPlayer->OnAchievementEarned( nAchievementID );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
VoiceCommandMenuItem_t *CMultiplayRules::VoiceCommand( CBaseMultiplayerPlayer *pPlayer, int iMenu, int iItem )
|
|
{
|
|
// have the player speak the concept that is in a particular menu slot
|
|
if ( !pPlayer )
|
|
return NULL;
|
|
|
|
if ( iMenu < 0 || iMenu >= m_VoiceCommandMenus.Count() )
|
|
return NULL;
|
|
|
|
if ( iItem < 0 || iItem >= m_VoiceCommandMenus.Element( iMenu ).Count() )
|
|
return NULL;
|
|
|
|
VoiceCommandMenuItem_t *pItem = &m_VoiceCommandMenus.Element( iMenu ).Element( iItem );
|
|
|
|
Assert( pItem );
|
|
|
|
char szResponse[AI_Response::MAX_RESPONSE_NAME];
|
|
|
|
if ( pPlayer->CanSpeakVoiceCommand() )
|
|
{
|
|
CMultiplayer_Expresser *pExpresser = pPlayer->GetMultiplayerExpresser();
|
|
Assert( pExpresser );
|
|
pExpresser->AllowMultipleScenes();
|
|
|
|
if ( pPlayer->SpeakConceptIfAllowed( pItem->m_iConcept, NULL, szResponse, AI_Response::MAX_RESPONSE_NAME ) )
|
|
{
|
|
// show a subtitle if we need to
|
|
if ( pItem->m_bShowSubtitle )
|
|
{
|
|
CRecipientFilter filter;
|
|
|
|
if ( pItem->m_bDistanceBasedSubtitle )
|
|
{
|
|
filter.AddRecipientsByPAS( pPlayer->WorldSpaceCenter() );
|
|
|
|
// further reduce the range to a certain radius
|
|
int i;
|
|
for ( i = filter.GetRecipientCount()-1; i >= 0; i-- )
|
|
{
|
|
int index = filter.GetRecipientIndex(i);
|
|
|
|
CBasePlayer *pListener = UTIL_PlayerByIndex( index );
|
|
|
|
if ( pListener && pListener != pPlayer )
|
|
{
|
|
float flDist = ( pListener->WorldSpaceCenter() - pPlayer->WorldSpaceCenter() ).Length2D();
|
|
|
|
if ( flDist > VOICE_COMMAND_MAX_SUBTITLE_DIST )
|
|
filter.RemoveRecipientByPlayerIndex( index );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
filter.AddAllPlayers();
|
|
}
|
|
|
|
// if we aren't a disguised spy
|
|
if ( !pPlayer->ShouldShowVoiceSubtitleToEnemy() )
|
|
{
|
|
// remove players on other teams
|
|
filter.RemoveRecipientsNotOnTeam( pPlayer->GetTeam() );
|
|
}
|
|
|
|
// Register this event in the mod-specific usermessages .cpp file if you hit this assert
|
|
Assert( usermessages->LookupUserMessage( "VoiceSubtitle" ) != -1 );
|
|
|
|
// Send a subtitle to anyone in the PAS
|
|
UserMessageBegin( filter, "VoiceSubtitle" );
|
|
WRITE_BYTE( pPlayer->entindex() );
|
|
WRITE_BYTE( iMenu );
|
|
WRITE_BYTE( iItem );
|
|
MessageEnd();
|
|
}
|
|
|
|
pPlayer->NoteSpokeVoiceCommand( szResponse );
|
|
|
|
#ifdef NEXT_BOT
|
|
// let bots react to player's voice commands
|
|
CUtlVector< INextBot * > botVector;
|
|
TheNextBots().CollectAllBots( &botVector );
|
|
|
|
for( int i=0; i<botVector.Count(); ++i )
|
|
{
|
|
botVector[i]->OnActorEmoted( pPlayer, pItem->m_iConcept );
|
|
}
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
pItem = NULL;
|
|
}
|
|
|
|
pExpresser->DisallowMultipleScenes();
|
|
return pItem;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
bool CMultiplayRules::IsLoadingBugBaitReport()
|
|
{
|
|
return ( !engine->IsDedicatedServer()&& CommandLine()->CheckParm( "-bugbait" ) && sv_cheats->GetBool() );
|
|
}
|
|
|
|
void CMultiplayRules::HaveAllPlayersSpeakConceptIfAllowed( int iConcept, int iTeam /* = TEAM_UNASSIGNED */, const char *modifiers /* = NULL */ )
|
|
{
|
|
CBaseMultiplayerPlayer *pPlayer;
|
|
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
|
|
{
|
|
pPlayer = ToBaseMultiplayerPlayer( UTIL_PlayerByIndex( i ) );
|
|
|
|
if ( !pPlayer )
|
|
continue;
|
|
|
|
if ( iTeam != TEAM_UNASSIGNED )
|
|
{
|
|
if ( pPlayer->GetTeamNumber() != iTeam )
|
|
continue;
|
|
}
|
|
|
|
pPlayer->SpeakConceptIfAllowed( iConcept, modifiers );
|
|
}
|
|
}
|
|
|
|
void CMultiplayRules::RandomPlayersSpeakConceptIfAllowed( int iConcept, int iNumRandomPlayer /*= 1*/, int iTeam /*= TEAM_UNASSIGNED*/, const char *modifiers /*= NULL*/ )
|
|
{
|
|
CUtlVector< CBaseMultiplayerPlayer* > speakCandidates;
|
|
|
|
CBaseMultiplayerPlayer *pPlayer;
|
|
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
|
|
{
|
|
pPlayer = ToBaseMultiplayerPlayer( UTIL_PlayerByIndex( i ) );
|
|
|
|
if ( !pPlayer )
|
|
continue;
|
|
|
|
if ( iTeam != TEAM_UNASSIGNED )
|
|
{
|
|
if ( pPlayer->GetTeamNumber() != iTeam )
|
|
continue;
|
|
}
|
|
|
|
speakCandidates.AddToTail( pPlayer );
|
|
}
|
|
|
|
int iSpeaker = iNumRandomPlayer;
|
|
while ( iSpeaker > 0 && speakCandidates.Count() > 0 )
|
|
{
|
|
int iRandomSpeaker = RandomInt( 0, speakCandidates.Count() - 1 );
|
|
speakCandidates[ iRandomSpeaker ]->SpeakConceptIfAllowed( iConcept, modifiers );
|
|
speakCandidates.FastRemove( iRandomSpeaker );
|
|
iSpeaker--;
|
|
}
|
|
}
|
|
|
|
void CMultiplayRules::ClientSettingsChanged( CBasePlayer *pPlayer )
|
|
{
|
|
// NVNT see if this user is still or has began using a haptic device
|
|
const char *pszHH = engine->GetClientConVarValue( pPlayer->entindex(), "hap_HasDevice" );
|
|
if( pszHH )
|
|
{
|
|
int iHH = atoi( pszHH );
|
|
pPlayer->SetHaptics( iHH != 0 );
|
|
}
|
|
|
|
}
|
|
void CMultiplayRules::GetTaggedConVarList( KeyValues *pCvarTagList )
|
|
{
|
|
BaseClass::GetTaggedConVarList( pCvarTagList );
|
|
|
|
// sv_gravity
|
|
KeyValues *pGravity = new KeyValues( "sv_gravity" );
|
|
pGravity->SetString( "convar", "sv_gravity" );
|
|
pGravity->SetString( "tag", "gravity" );
|
|
|
|
pCvarTagList->AddSubKey( pGravity );
|
|
|
|
// sv_alltalk
|
|
KeyValues *pAllTalk = new KeyValues( "sv_alltalk" );
|
|
pAllTalk->SetString( "convar", "sv_alltalk" );
|
|
pAllTalk->SetString( "tag", "alltalk" );
|
|
|
|
pCvarTagList->AddSubKey( pAllTalk );
|
|
}
|
|
|
|
#else
|
|
|
|
const char *CMultiplayRules::GetVoiceCommandSubtitle( int iMenu, int iItem )
|
|
{
|
|
Assert( iMenu >= 0 && iMenu < m_VoiceCommandMenus.Count() );
|
|
if ( iMenu < 0 || iMenu >= m_VoiceCommandMenus.Count() )
|
|
return "";
|
|
|
|
Assert( iItem >= 0 && iItem < m_VoiceCommandMenus.Element( iMenu ).Count() );
|
|
if ( iItem < 0 || iItem >= m_VoiceCommandMenus.Element( iMenu ).Count() )
|
|
return "";
|
|
|
|
VoiceCommandMenuItem_t *pItem = &m_VoiceCommandMenus.Element( iMenu ).Element( iItem );
|
|
|
|
Assert( pItem );
|
|
|
|
return pItem->m_szSubtitle;
|
|
}
|
|
|
|
// Returns false if no such menu is declared or if it's an empty menu
|
|
bool CMultiplayRules::GetVoiceMenuLabels( int iMenu, KeyValues *pKV )
|
|
{
|
|
Assert( iMenu >= 0 && iMenu < m_VoiceCommandMenus.Count() );
|
|
if ( iMenu < 0 || iMenu >= m_VoiceCommandMenus.Count() )
|
|
return false;
|
|
|
|
int iNumItems = m_VoiceCommandMenus.Element( iMenu ).Count();
|
|
|
|
for ( int i=0; i<iNumItems; i++ )
|
|
{
|
|
VoiceCommandMenuItem_t *pItem = &m_VoiceCommandMenus.Element( iMenu ).Element( i );
|
|
|
|
KeyValues *pLabelKV = new KeyValues( pItem->m_szMenuLabel );
|
|
|
|
pKV->AddSubKey( pLabelKV );
|
|
}
|
|
|
|
return iNumItems > 0;
|
|
}
|
|
|
|
#endif
|