sourcemod-central: core/PlayerManager.cpp@ccd11f0c5372

     1 /**

     2  * vim: set ts=4 sw=4 tw=99 noet :

     3  * =============================================================================

     4  * SourceMod

     5  * Copyright (C) 2004-2009 AlliedModders LLC.  All rights reserved.

     6  * =============================================================================

     7  *

     8  * This program is free software; you can redistribute it and/or modify it under

     9  * the terms of the GNU General Public License, version 3.0, as published by the

    10  * Free Software Foundation.

    11  *

    12  * This program is distributed in the hope that it will be useful, but WITHOUT

    13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

    14  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more

    15  * details.

    16  *

    17  * You should have received a copy of the GNU General Public License along with

    18  * this program.  If not, see <http://www.gnu.org/licenses/>.

    19  *

    20  * As a special exception, AlliedModders LLC gives you permission to link the

    21  * code of this program (as well as its derivative works) to "Half-Life 2," the

    22  * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software

    23  * by the Valve Corporation.  You must obey the GNU General Public License in

    24  * all respects for all other code used.  Additionally, AlliedModders LLC grants

    25  * this exception to all derivative works.  AlliedModders LLC defines further

    26  * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),

    27  * or <http://www.sourcemod.net/license.php>.

    28  *

    29  * Version: $Id$

    30  */

    32 #include "PlayerManager.h"

    33 #include "ForwardSys.h"

    34 #include "ShareSys.h"

    35 #include "AdminCache.h"

    36 #include "ConCmdManager.h"

    37 #include "MenuStyle_Valve.h"

    38 #include "MenuStyle_Radio.h"

    39 #include "sm_stringutil.h"

    40 #include "CoreConfig.h"

    41 #include "TimerSys.h"

    42 #include "Logger.h"

    43 #include "ChatTriggers.h"

    44 #include "HalfLife2.h"

    45 #include <inetchannel.h>

    46 #include <iclient.h>

    47 #include <IGameConfigs.h>

    48 #include "ExtensionSys.h"

    49 #include <sourcemod_version.h>

    50 #include "ConsoleDetours.h"

    51 #include "logic_bridge.h"

    53 PlayerManager g_Players;

    54 bool g_OnMapStarted = false;

    55 IForward *PreAdminCheck = NULL;

    56 IForward *PostAdminCheck = NULL;

    57 IForward *PostAdminFilter = NULL;

    59 const unsigned int *g_NumPlayersToAuth = NULL;

    60 int lifestate_offset = -1;

    61 List<ICommandTargetProcessor *> target_processors;

    63 SH_DECL_HOOK5(IServerGameClients, ClientConnect, SH_NOATTRIB, 0, bool, edict_t *, const char *, const char *, char *, int);

    64 SH_DECL_HOOK2_void(IServerGameClients, ClientPutInServer, SH_NOATTRIB, 0, edict_t *, const char *);

    65 SH_DECL_HOOK1_void(IServerGameClients, ClientDisconnect, SH_NOATTRIB, 0, edict_t *);

    66 #if SOURCE_ENGINE >= SE_ORANGEBOX

    67 SH_DECL_HOOK2_void(IServerGameClients, ClientCommand, SH_NOATTRIB, 0, edict_t *, const CCommand &);

    68 #else

    69 SH_DECL_HOOK1_void(IServerGameClients, ClientCommand, SH_NOATTRIB, 0, edict_t *);

    70 #endif

    71 SH_DECL_HOOK1_void(IServerGameClients, ClientSettingsChanged, SH_NOATTRIB, 0, edict_t *);

    72 SH_DECL_HOOK3_void(IServerGameDLL, ServerActivate, SH_NOATTRIB, 0, edict_t *, int, int);

    74 #if SOURCE_ENGINE >= SE_ORANGEBOX

    75 SH_DECL_EXTERN1_void(ConCommand, Dispatch, SH_NOATTRIB, false, const CCommand &);

    76 #elif SOURCE_ENGINE == SE_DARKMESSIAH

    77 SH_DECL_EXTERN0_void(ConCommand, Dispatch, SH_NOATTRIB, false);

    78 #else

    79 # if SH_IMPL_VERSION >= 4

    80  extern int __SourceHook_FHAddConCommandDispatch(void *,bool,class fastdelegate::FastDelegate0<void>);

    81 # else

    82  extern bool __SourceHook_FHAddConCommandDispatch(void *,bool,class fastdelegate::FastDelegate0<void>);

    83 # endif

    84 extern bool __SourceHook_FHRemoveConCommandDispatch(void *,bool,class fastdelegate::FastDelegate0<void>);

    85 #endif

    87 ConCommand *maxplayersCmd = NULL;

    89 unsigned int g_PlayerSerialCount = 0;

    91 class KickPlayerTimer : public ITimedEvent

    92 {

    93 public:

    94 	ResultType OnTimer(ITimer *pTimer, void *pData)

    95 	{

    96 		int userid = (int)pData;

    97 		int client = g_Players.GetClientOfUserId(userid);

    98 		if (client)

    99 		{

   100 			CPlayer *player = g_Players.GetPlayerByIndex(client);

   101 			player->Kick("Your name is reserved by SourceMod; set your password to use it.");

   102 		}

   103 		return Pl_Stop;

   104 	}

   105 	void OnTimerEnd(ITimer *pTimer, void *pData)

   106 	{

   107 	}

   108 } s_KickPlayerTimer;

   110 PlayerManager::PlayerManager()

   111 {

   112 	m_AuthQueue = NULL;

   113 	m_FirstPass = false;

   114 	m_maxClients = 0;

   116 	m_SourceTVUserId = -1;

   117 	m_ReplayUserId = -1;

   119 	m_UserIdLookUp = new int[USHRT_MAX+1];

   120 	memset(m_UserIdLookUp, 0, sizeof(int) * (USHRT_MAX+1));

   121 }

   123 PlayerManager::~PlayerManager()

   124 {

   125 	g_NumPlayersToAuth = NULL;

   127 	delete [] m_AuthQueue;

   128 	delete [] m_UserIdLookUp;

   129 }

   131 void PlayerManager::OnSourceModAllInitialized()

   132 {

   133 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect, false);

   134 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect_Post, true);

   135 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientPutInServer, serverClients, this, &PlayerManager::OnClientPutInServer, true);

   136 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect, false);

   137 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect_Post, true);

   138 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientCommand, serverClients, this, &PlayerManager::OnClientCommand, false);

   139 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientSettingsChanged, serverClients, this, &PlayerManager::OnClientSettingsChanged, true);

   140 	SH_ADD_HOOK_MEMFUNC(IServerGameDLL, ServerActivate, gamedll, this, &PlayerManager::OnServerActivate, true);

   142 	g_ShareSys.AddInterface(NULL, this);

   144 	ParamType p1[] = {Param_Cell, Param_String, Param_Cell};

   145 	ParamType p2[] = {Param_Cell};

   147 	m_clconnect = g_Forwards.CreateForward("OnClientConnect", ET_LowEvent, 3, p1);

   148 	m_clconnect_post = g_Forwards.CreateForward("OnClientConnected", ET_Ignore, 1, p2);

   149 	m_clputinserver = g_Forwards.CreateForward("OnClientPutInServer", ET_Ignore, 1, p2);

   150 	m_cldisconnect = g_Forwards.CreateForward("OnClientDisconnect", ET_Ignore, 1, p2);

   151 	m_cldisconnect_post = g_Forwards.CreateForward("OnClientDisconnect_Post", ET_Ignore, 1, p2);

   152 	m_clcommand = g_Forwards.CreateForward("OnClientCommand", ET_Hook, 2, NULL, Param_Cell, Param_Cell);

   153 	m_clinfochanged = g_Forwards.CreateForward("OnClientSettingsChanged", ET_Ignore, 1, p2);

   154 	m_clauth = g_Forwards.CreateForward("OnClientAuthorized", ET_Ignore, 2, NULL, Param_Cell, Param_String);

   155 	m_onActivate = g_Forwards.CreateForward("OnServerLoad", ET_Ignore, 0, NULL);

   156 	m_onActivate2 = g_Forwards.CreateForward("OnMapStart", ET_Ignore, 0, NULL);

   158 	PreAdminCheck = g_Forwards.CreateForward("OnClientPreAdminCheck", ET_Event, 1, p1);

   159 	PostAdminCheck = g_Forwards.CreateForward("OnClientPostAdminCheck", ET_Ignore, 1, p1);

   160 	PostAdminFilter = g_Forwards.CreateForward("OnClientPostAdminFilter", ET_Ignore, 1, p1);

   162 	m_bIsListenServer = !engine->IsDedicatedServer();

   163 	m_ListenClient = 0;

   165 	ConCommand *pCmd = FindCommand("maxplayers");

   166 	if (pCmd != NULL)

   167 	{

   168 		SH_ADD_HOOK_STATICFUNC(ConCommand, Dispatch, pCmd, CmdMaxplayersCallback, true);

   169 		maxplayersCmd = pCmd;

   170 	}

   171 }

   173 void PlayerManager::OnSourceModShutdown()

   174 {

   175 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect, false);

   176 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect_Post, true);

   177 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientPutInServer, serverClients, this, &PlayerManager::OnClientPutInServer, true);

   178 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect, false);

   179 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect_Post, true);

   180 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientCommand, serverClients, this, &PlayerManager::OnClientCommand, false);

   181 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientSettingsChanged, serverClients, this, &PlayerManager::OnClientSettingsChanged, true);

   182 	SH_REMOVE_HOOK_MEMFUNC(IServerGameDLL, ServerActivate, gamedll, this, &PlayerManager::OnServerActivate, true);

   184 	/* Release forwards */

   185 	g_Forwards.ReleaseForward(m_clconnect);

   186 	g_Forwards.ReleaseForward(m_clconnect_post);

   187 	g_Forwards.ReleaseForward(m_clputinserver);

   188 	g_Forwards.ReleaseForward(m_cldisconnect);

   189 	g_Forwards.ReleaseForward(m_cldisconnect_post);

   190 	g_Forwards.ReleaseForward(m_clcommand);

   191 	g_Forwards.ReleaseForward(m_clinfochanged);

   192 	g_Forwards.ReleaseForward(m_clauth);

   193 	g_Forwards.ReleaseForward(m_onActivate);

   194 	g_Forwards.ReleaseForward(m_onActivate2);

   196 	g_Forwards.ReleaseForward(PreAdminCheck);

   197 	g_Forwards.ReleaseForward(PostAdminCheck);

   198 	g_Forwards.ReleaseForward(PostAdminFilter);

   200 	delete [] m_Players;

   202 	if (maxplayersCmd != NULL)

   203 	{

   204 		SH_REMOVE_HOOK_STATICFUNC(ConCommand, Dispatch, maxplayersCmd, CmdMaxplayersCallback, true);

   205 	}

   206 }

   208 ConfigResult PlayerManager::OnSourceModConfigChanged(const char *key,

   209 												 const char *value,

   210 												 ConfigSource source,

   211 												 char *error,

   212 												 size_t maxlength)

   213 {

   214 	if (strcmp(key, "PassInfoVar") == 0)

   215 	{

   216 		if (strcmp(value, "_password") != 0)

   217 		{

   218 			m_PassInfoVar.assign(value);

   219 		}

   220 		return ConfigResult_Accept;

   221 	} else if (strcmp(key, "AllowClLanguageVar") == 0) {

   222 		if (strcasecmp(value, "on") == 0)

   223 		{

   224 			m_QueryLang = true;

   225 		} else if (strcasecmp(value, "off") == 0) {

   226 			m_QueryLang = false;

   227 		} else {

   228 			UTIL_Format(error, maxlength, "Invalid value: must be \"on\" or \"off\"");

   229 			return ConfigResult_Reject;

   230 		}

   231 		return ConfigResult_Accept;

   232 	}

   233 	return ConfigResult_Ignore;

   234 }

   236 void PlayerManager::OnServerActivate(edict_t *pEdictList, int edictCount, int clientMax)

   237 {

   238 	static ConVar *tv_enable = icvar->FindVar("tv_enable");

   239 #if SOURCE_ENGINE == SE_ORANGEBOXVALVE

   240 	static ConVar *replay_enable = icvar->FindVar("replay_enable");

   241 #endif

   243 	// clientMax will not necessarily be correct here (such as on late SourceTV enable)

   244 	m_maxClients = gpGlobals->maxClients;

   246 	ICommandLine *commandLine = g_HL2.GetValveCommandLine();

   247 	m_bIsSourceTVActive = (tv_enable && tv_enable->GetBool() && (!commandLine || commandLine->FindParm("-nohltv") == 0));

   248 	m_bIsReplayActive = false;

   249 #if SOURCE_ENGINE == SE_ORANGEBOXVALVE

   250 	m_bIsReplayActive = (replay_enable && replay_enable->GetBool());

   251 #endif

   252 	m_PlayersSinceActive = 0;

   254 	if (!m_FirstPass)

   255 	{

   256 		/* Initialize all players */

   258 		m_PlayerCount = 0;

   259 		m_Players = new CPlayer[ABSOLUTE_PLAYER_LIMIT + 1];

   260 		m_AuthQueue = new unsigned int[ABSOLUTE_PLAYER_LIMIT + 1];

   261 		m_FirstPass = true;

   263 		memset(m_AuthQueue, 0, sizeof(unsigned int) * (ABSOLUTE_PLAYER_LIMIT + 1));

   265 		g_NumPlayersToAuth = &m_AuthQueue[0];

   266 	}

   268 	g_PluginSys.SyncMaxClients(m_maxClients);

   270 	g_OnMapStarted = true;

   272 	g_Extensions.CallOnCoreMapStart(pEdictList, edictCount, m_maxClients);

   273 	m_onActivate->Execute(NULL);

   274 	m_onActivate2->Execute(NULL);

   276 	List<IClientListener *>::iterator iter;

   277 	for (iter = m_hooks.begin(); iter != m_hooks.end(); iter++)

   278 	{

   279 		if ((*iter)->GetClientListenerVersion() >= 5)

   280 		{

   281 			(*iter)->OnServerActivated(m_maxClients);

   282 		}

   283 	}

   285 	SMGlobalClass *cls = SMGlobalClass::head;

   286 	while (cls)

   287 	{

   288 		cls->OnSourceModLevelActivated();

   289 		cls = cls->m_pGlobalClassNext;

   290 	}

   292 	SM_ExecuteAllConfigs();

   293 }

   295 bool PlayerManager::IsServerActivated()

   296 {

   297 	return m_FirstPass;

   298 }

   300 bool PlayerManager::CheckSetAdmin(int index, CPlayer *pPlayer, AdminId id)

   301 {

   302 	const char *password = g_Admins.GetAdminPassword(id);

   303 	if (password != NULL)

   304 	{

   305 		if (m_PassInfoVar.size() < 1)

   306 		{

   307 			return false;

   308 		}

   310 		/* Whoa... the user needs a password! */

   311 		const char *given = engine->GetClientConVarValue(index, m_PassInfoVar.c_str());

   312 		if (!given || strcmp(given, password) != 0)

   313 		{

   314 			return false;

   315 		}

   316 	}

   318 	pPlayer->SetAdminId(id, false);

   320 	return true;

   321 }

   323 bool PlayerManager::CheckSetAdminName(int index, CPlayer *pPlayer, AdminId id)

   324 {

   325 	const char *password = g_Admins.GetAdminPassword(id);

   326 	if (password == NULL)

   327 	{

   328 		return false;

   329 	}

   331 	if (m_PassInfoVar.size() < 1)

   332 	{

   333 		return false;

   334 	}

   336 	/* Whoa... the user needs a password! */

   337 	const char *given = engine->GetClientConVarValue(index, m_PassInfoVar.c_str());

   338 	if (!given || strcmp(given, password) != 0)

   339 	{

   340 		return false;

   341 	}

   343 	pPlayer->SetAdminId(id, false);

   345 	return true;

   346 }

   348 void PlayerManager::RunAuthChecks()

   349 {

   350 	CPlayer *pPlayer;

   351 	const char *authstr;

   352 	unsigned int removed = 0;

   353 	for (unsigned int i=1; i<=m_AuthQueue[0]; i++)

   354 	{

   355 		pPlayer = &m_Players[m_AuthQueue[i]];

   356 		authstr = engine->GetPlayerNetworkIDString(pPlayer->m_pEdict);

   357 		if (authstr && authstr[0] != '\0'

   358 			&& (strcmp(authstr, "STEAM_ID_PENDING") != 0))

   359 		{

   360 			/* Set authorization */

   361 			pPlayer->Authorize(authstr);

   363 			/* Mark as removed from queue */

   364 			unsigned int client = m_AuthQueue[i];

   365 			m_AuthQueue[i] = 0;

   366 			removed++;

   368 			/* Send to extensions */

   369 			List<IClientListener *>::iterator iter;

   370 			IClientListener *pListener;

   371 			for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

   372 			{

   373 				pListener = (*iter);

   374 				pListener->OnClientAuthorized(client, authstr);

   375 				if (!pPlayer->IsConnected())

   376 				{

   377 					break;

   378 				}

   379 			}

   381 			/* Send to plugins if player is still connected */

   382 			if (pPlayer->IsConnected() && m_clauth->GetFunctionCount())

   383 			{

   384 				/* :TODO: handle the case of a player disconnecting in the middle */

   385 				m_clauth->PushCell(client);

   386 				m_clauth->PushString(authstr);

   387 				m_clauth->Execute(NULL);

   388 			}

   390 			if (pPlayer->IsConnected())

   391 			{

   392 				pPlayer->Authorize_Post();

   393 			}

   394 		}

   395 	}

   397 	/* Clean up the queue */

   398 	if (removed)

   399 	{

   400 		/* We don't have to compact the list if it's empty */

   401 		if (removed != m_AuthQueue[0])

   402 		{

   403 			unsigned int diff = 0;

   404 			for (unsigned int i=1; i<=m_AuthQueue[0]; i++)

   405 			{

   406 				/* If this member is removed... */

   407 				if (m_AuthQueue[i] == 0)

   408 				{

   409 					/* Increase the differential */

   410 					diff++;

   411 				} else {

   412 					/* diff cannot increase faster than i+1 */

   413 					assert(i > diff);

   414 					assert(i - diff >= 1);

   415 					/* move this index down */

   416 					m_AuthQueue[i - diff] = m_AuthQueue[i];

   417 				}

   418 			}

   419 			m_AuthQueue[0] -= removed;

   420 		} else {

   421 			m_AuthQueue[0] = 0;

   422 		}

   423 	}

   424 }

   426 bool PlayerManager::OnClientConnect(edict_t *pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen)

   427 {

   428 	int client = IndexOfEdict(pEntity);

   429 	CPlayer *pPlayer = &m_Players[client];

   430 	++m_PlayersSinceActive;

   432 	pPlayer->Initialize(pszName, pszAddress, pEntity);

   434 	/* Get the client's language */

   435 	if (m_QueryLang)

   436 	{

   437 		const char *name;

   438 		if (!pPlayer->IsFakeClient() && (name=engine->GetClientConVarValue(client, "cl_language")))

   439 		{

   440 			unsigned int langid;

   441 			pPlayer->m_LangId = (translator->GetLanguageByName(name, &langid)) ? langid : translator->GetServerLanguage();

   442 		} else {

   443 			pPlayer->m_LangId = translator->GetServerLanguage();

   444 		}

   445 	}

   447 	List<IClientListener *>::iterator iter;

   448 	IClientListener *pListener = NULL;

   449 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

   450 	{

   451 		pListener = (*iter);

   452 		if (!pListener->InterceptClientConnect(client, reject, maxrejectlen))

   453 		{

   454 			return false;

   455 		}

   456 	}

   458 	cell_t res = 1;

   460 	m_clconnect->PushCell(client);

   461 	m_clconnect->PushStringEx(reject, maxrejectlen, SM_PARAM_STRING_UTF8 | SM_PARAM_STRING_COPY, SM_PARAM_COPYBACK);

   462 	m_clconnect->PushCell(maxrejectlen);

   463 	m_clconnect->Execute(&res);

   465 	if (res)

   466 	{

   467 		if (!pPlayer->IsAuthorized())

   468 		{

   469 			m_AuthQueue[++m_AuthQueue[0]] = client;

   470 		}

   472 		m_UserIdLookUp[engine->GetPlayerUserId(pEntity)] = client;

   473 	}

   474 	else

   475 	{

   476 		if (!pPlayer->IsFakeClient())

   477 		{

   478 			RETURN_META_VALUE(MRES_SUPERCEDE, false);

   479 		}

   480 	}

   482 	return true;

   483 }

   485 bool PlayerManager::OnClientConnect_Post(edict_t *pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen)

   486 {

   487 	int client = IndexOfEdict(pEntity);

   488 	bool orig_value = META_RESULT_ORIG_RET(bool);

   489 	CPlayer *pPlayer = &m_Players[client];

   491 	if (orig_value)

   492 	{

   493 		List<IClientListener *>::iterator iter;

   494 		IClientListener *pListener = NULL;

   495 		for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

   496 		{

   497 			pListener = (*iter);

   498 			pListener->OnClientConnected(client);

   499 			if (!pPlayer->IsConnected())

   500 			{

   501 				return true;

   502 			}

   503 		}

   505 		if (!pPlayer->IsFakeClient()

   506 			&& m_bIsListenServer

   507 			&& strncmp(pszAddress, "127.0.0.1", 9) == 0)

   508 		{

   509 			m_ListenClient = client;

   510 		}

   512 		cell_t res;

   513 		m_clconnect_post->PushCell(client);

   514 		m_clconnect_post->Execute(&res, NULL);

   515 	}

   516 	else

   517 	{

   518 		InvalidatePlayer(pPlayer);

   519 	}

   521 	return true;

   522 }

   524 void PlayerManager::OnClientPutInServer(edict_t *pEntity, const char *playername)

   525 {

   526 	cell_t res;

   527 	int client = IndexOfEdict(pEntity);

   528 	CPlayer *pPlayer = &m_Players[client];

   530 	/* If they're not connected, they're a bot */

   531 	if (!pPlayer->IsConnected())

   532 	{

   533 		/* Run manual connection routines */

   534 		char error[255];

   535 		const char *authid = engine->GetPlayerNetworkIDString(pEntity);

   536 		pPlayer->Authorize(authid);

   537 		pPlayer->m_bFakeClient = true;

   539 		/*

   540 		 * While we're already filtered to just bots, we'll do other checks to

   541 		 * make sure that the requisite services are enabled and that the bots

   542 		 * have joined at the expected time.

   543 		 *

   544 		 * Checking playerinfo's IsHLTV and IsReplay would be better and less

   545 		 * error-prone but will always show false until later in the frame,

   546 		 * after PutInServer and Activate, and we want it now!

   547 		 */

   549 		// This doesn't actually get incremented until OnClientConnect. Fake it to check.

   550 		int newCount = m_PlayersSinceActive + 1;

   551 		int userId = engine->GetPlayerUserId(pEntity);

   553 #if SOURCE_ENGINE == SE_ORANGEBOXVALVE

   554 		if (m_bIsReplayActive && newCount == 1

   555 			&& (m_ReplayUserId == userId || strcmp(playername, "Replay") == 0))

   556 		{

   557 			pPlayer->m_bIsReplay = true;

   558 			m_ReplayUserId = userId;

   559 		}

   560 #endif

   562 		if (m_bIsSourceTVActive

   563 			&& ((!m_bIsReplayActive && newCount == 1)

   564 				|| (m_bIsReplayActive && newCount == 2))

   565 			&& (m_SourceTVUserId == userId || strcmp(playername, "SourceTV") == 0)

   566 			)

   567 		{

   568 			pPlayer->m_bIsSourceTV = true;

   569 			m_SourceTVUserId = userId;

   570 		}

   572 		if (!OnClientConnect(pEntity, playername, "127.0.0.1", error, sizeof(error)))

   573 		{

   574 			/* :TODO: kick the bot if it's rejected */

   575 			return;

   576 		}

   577 		List<IClientListener *>::iterator iter;

   578 		IClientListener *pListener = NULL;

   579 		for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

   580 		{

   581 			pListener = (*iter);

   582 			pListener->OnClientConnected(client);

   583 			/* See if bot was kicked */

   584 			if (!pPlayer->IsConnected())

   585 			{

   586 				return;

   587 			}

   588 		}

   590 		cell_t res;

   591 		m_clconnect_post->PushCell(client);

   592 		m_clconnect_post->Execute(&res, NULL);

   594 		/* Now do authorization */

   595 		for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

   596 		{

   597 			pListener = (*iter);

   598 			pListener->OnClientAuthorized(client, authid);

   599 		}

   600 		/* Finally, tell plugins */

   601 		if (m_clauth->GetFunctionCount())

   602 		{

   603 			m_clauth->PushCell(client);

   604 			m_clauth->PushString(authid);

   605 			m_clauth->Execute(NULL);

   606 		}

   607 		pPlayer->Authorize_Post();

   608 	}

   610 	if (playerinfo)

   611 	{

   612 		pPlayer->m_Info = playerinfo->GetPlayerInfo(pEntity);

   613 	}

   615 	pPlayer->Connect();

   616 	m_PlayerCount++;

   618 	List<IClientListener *>::iterator iter;

   619 	IClientListener *pListener = NULL;

   620 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

   621 	{

   622 		pListener = (*iter);

   623 		pListener->OnClientPutInServer(client);

   624 	}

   626 	m_clputinserver->PushCell(client);

   627 	m_clputinserver->Execute(&res, NULL);

   629 	if (pPlayer->IsAuthorized())

   630 	{

   631 		pPlayer->DoPostConnectAuthorization();

   632 	}

   633 }

   635 void PlayerManager::OnSourceModLevelEnd()

   636 {

   637 	/* Disconnect all bots still in game */

   638 	for (int i=1; i<=m_maxClients; i++)

   639 	{

   640 		if (m_Players[i].IsConnected())

   641 		{

   642 			OnClientDisconnect(m_Players[i].GetEdict());

   643 		}

   644 	}

   645 	m_PlayerCount = 0;

   646 }

   648 void PlayerManager::OnClientDisconnect(edict_t *pEntity)

   649 {

   650 	cell_t res;

   651 	int client = IndexOfEdict(pEntity);

   652 	CPlayer *pPlayer = &m_Players[client];

   654 	if (pPlayer->IsConnected())

   655 	{

   656 		m_cldisconnect->PushCell(client);

   657 		m_cldisconnect->Execute(&res, NULL);

   658 	}

   659 	else

   660 	{

   661 		/* We don't care, prevent a double call */

   662 		return;

   663 	}

   665 	if (pPlayer->WasCountedAsInGame())

   666 	{

   667 		m_PlayerCount--;

   668 	}

   670 	List<IClientListener *>::iterator iter;

   671 	IClientListener *pListener = NULL;

   672 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

   673 	{

   674 		pListener = (*iter);

   675 		pListener->OnClientDisconnecting(client);

   676 	}

   678 	InvalidatePlayer(pPlayer);

   680 	if (m_ListenClient == client)

   681 	{

   682 		m_ListenClient = 0;

   683 	}

   684 }

   686 void PlayerManager::OnClientDisconnect_Post(edict_t *pEntity)

   687 {

   688 	cell_t res;

   689 	int client = IndexOfEdict(pEntity);

   691 	m_cldisconnect_post->PushCell(client);

   692 	m_cldisconnect_post->Execute(&res, NULL);

   694 	List<IClientListener *>::iterator iter;

   695 	IClientListener *pListener = NULL;

   696 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

   697 	{

   698 		pListener = (*iter);

   699 		pListener->OnClientDisconnected(client);

   700 	}

   701 }

   703 void ClientConsolePrint(edict_t *e, const char *fmt, ...)

   704 {

   705 	char buffer[512];

   707 	va_list ap;

   708 	va_start(ap, fmt);

   709 	size_t len = vsnprintf(buffer, sizeof(buffer), fmt, ap);

   710 	va_end(ap);

   712 	if (len >= sizeof(buffer) - 1)

   713 	{

   714 		buffer[sizeof(buffer) - 2] = '\n';

   715 		buffer[sizeof(buffer) - 1] = '\0';

   716 	} else {

   717 		buffer[len++] = '\n';

   718 		buffer[len] = '\0';

   719 	}

   721 	engine->ClientPrintf(e, buffer);

   722 }

   724 #if SOURCE_ENGINE >= SE_ORANGEBOX

   725 void PlayerManager::OnClientCommand(edict_t *pEntity, const CCommand &args)

   726 {

   727 #else

   728 void PlayerManager::OnClientCommand(edict_t *pEntity)

   729 {

   730 	CCommand args;

   731 #endif

   732 	int client = IndexOfEdict(pEntity);

   733 	cell_t res = Pl_Continue;

   734 	CPlayer *pPlayer = &m_Players[client];

   736 	if (!pPlayer->IsConnected())

   737 	{

   738 		return;

   739 	}

   741 	if (strcmp(args.Arg(0), "sm") == 0)

   742 	{

   743 		if (args.ArgC() > 1 && strcmp(args.Arg(1), "plugins") == 0)

   744 		{

   745 			g_PluginSys.ListPluginsToClient(pPlayer, args);

   746 			RETURN_META(MRES_SUPERCEDE);

   747 		}

   748 		else if (args.ArgC() > 1 && strcmp(args.Arg(1), "credits") == 0)

   749 		{

   750 			ClientConsolePrint(pEntity,

   751 				"SourceMod would not be possible without:");

   752 			ClientConsolePrint(pEntity,

   753 				" David \"BAILOPAN\" Anderson, Borja \"faluco\" Ferrer");

   754 			ClientConsolePrint(pEntity,

   755 				" Scott \"DS\" Ehlert, Matt \"pRED\" Woodrow");

   756 			ClientConsolePrint(pEntity,

   757 				" Michael \"ferret\" McKoy, Pavol \"PM OnoTo\" Marko");

   758 			ClientConsolePrint(pEntity,

   759 				"SourceMod is open source under the GNU General Public License.");

   760 			RETURN_META(MRES_SUPERCEDE);

   761 		}

   763 		ClientConsolePrint(pEntity,

   764 			"SourceMod %s, by AlliedModders LLC", SM_FULL_VERSION);

   765 		ClientConsolePrint(pEntity,

   766 			"To see running plugins, type \"sm plugins\"");

   767 		ClientConsolePrint(pEntity,

   768 			"To see credits, type \"sm credits\"");

   769 		ClientConsolePrint(pEntity,

   770 			"Visit http://www.sourcemod.net/");

   771 		RETURN_META(MRES_SUPERCEDE);

   772 	}

   774 	g_HL2.PushCommandStack(&args);

   776 	int argcount = args.ArgC() - 1;

   777 	const char *cmd = g_HL2.CurrentCommandName();

   779 	bool result = g_ValveMenuStyle.OnClientCommand(client, cmd, args);

   780 	if (result)

   781 	{

   782 		res = Pl_Handled;

   783 	} else {

   784 		result = g_RadioMenuStyle.OnClientCommand(client, cmd, args);

   785 		if (result)

   786 		{

   787 			res = Pl_Handled;

   788 		}

   789 	}

   791 	if (g_ConsoleDetours.IsEnabled())

   792 	{

   793 		cell_t res2 = g_ConsoleDetours.InternalDispatch(client, args);

   794 		if (res2 >= Pl_Stop)

   795 		{

   796 			g_HL2.PopCommandStack();

   797 			RETURN_META(MRES_SUPERCEDE);

   798 		}

   799 		else if (res2 > res)

   800 		{

   801 			res = res2;

   802 		}

   803 	}

   805 	cell_t res2 = Pl_Continue;

   806 	if (pPlayer->IsInGame())

   807 	{

   808 		m_clcommand->PushCell(client);

   809 		m_clcommand->PushCell(argcount);

   810 		m_clcommand->Execute(&res2, NULL);

   811 	}

   813 	if (res2 > res)

   814 	{

   815 		res = res2;

   816 	}

   818 	if (res >= Pl_Stop)

   819 	{

   820 		g_HL2.PopCommandStack();

   821 		RETURN_META(MRES_SUPERCEDE);

   822 	}

   824 	res = g_ConCmds.DispatchClientCommand(client, cmd, argcount, (ResultType)res);

   826 	g_HL2.PopCommandStack();

   828 	if (res >= Pl_Handled)

   829 	{

   830 		RETURN_META(MRES_SUPERCEDE);

   831 	}

   832 }

   834 void PlayerManager::OnClientSettingsChanged(edict_t *pEntity)

   835 {

   836 	cell_t res;

   837 	int client = IndexOfEdict(pEntity);

   838 	CPlayer *pPlayer = &m_Players[client];

   840 	if (!pPlayer->IsConnected())

   841 	{

   842 		return;

   843 	}

   845 	m_clinfochanged->PushCell(client);

   846 	m_clinfochanged->Execute(&res, NULL);

   848 	if (pPlayer->IsFakeClient())

   849 	{

   850 		return;

   851 	}

   853 	IPlayerInfo *info = pPlayer->GetPlayerInfo();

   854 	const char *new_name = info ? info->GetName() : engine->GetClientConVarValue(client, "name");

   855 	const char *old_name = pPlayer->m_Name.c_str();

   857 	if (strcmp(old_name, new_name) != 0)

   858 	{

   859 		AdminId id = g_Admins.FindAdminByIdentity("name", new_name);

   860 		if (id != INVALID_ADMIN_ID && pPlayer->GetAdminId() != id)

   861 		{

   862 			if (!CheckSetAdminName(client, pPlayer, id))

   863 			{

   864 				pPlayer->Kick("Your name is reserved by SourceMod; set your password to use it.");

   865 				RETURN_META(MRES_IGNORED);

   866 			}

   867 		} else if ((id = g_Admins.FindAdminByIdentity("name", old_name)) != INVALID_ADMIN_ID) {

   868 			if (id == pPlayer->GetAdminId())

   869 			{

   870 				/* This player is changing their name; force them to drop admin privileges! */

   871 				pPlayer->SetAdminId(INVALID_ADMIN_ID, false);

   872 			}

   873 		}

   874 		pPlayer->SetName(new_name);

   875 	}

   877 	if (m_PassInfoVar.size() > 0)

   878 	{

   879 		/* Try for a password change */

   880 		const char *old_pass = pPlayer->m_LastPassword.c_str();

   881 		const char *new_pass = engine->GetClientConVarValue(client, m_PassInfoVar.c_str());

   882 		if (strcmp(old_pass, new_pass) != 0)

   883 		{

   884 			pPlayer->m_LastPassword.assign(new_pass);

   885 			if (pPlayer->IsInGame() && pPlayer->IsAuthorized())

   886 			{

   887 				/* If there is already an admin id assigned, this will just bail out. */

   888 				pPlayer->DoBasicAdminChecks();

   889 			}

   890 		}

   891 	}

   892 	/* Notify Extensions */

   893 	List<IClientListener *>::iterator iter;

   894 	IClientListener *pListener = NULL;

   895 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

   896 	{

   897 		pListener = (*iter);

   898 		if (pListener->GetClientListenerVersion() >= 13)

   899 		{

   900 			pListener->OnClientSettingsChanged(client);

   901 		}

   902 	}

   903 }

   905 int PlayerManager::GetMaxClients()

   906 {

   907 	return m_maxClients;

   908 }

   910 CPlayer *PlayerManager::GetPlayerByIndex(int client) const

   911 {

   912 	if (client > m_maxClients || client < 1)

   913 	{

   914 		return NULL;

   915 	}

   916 	return &m_Players[client];

   917 }

   919 int PlayerManager::GetNumPlayers()

   920 {

   921 	return m_PlayerCount;

   922 }

   924 int PlayerManager::GetClientOfUserId(int userid)

   925 {

   926 	if (userid < 0 || userid > USHRT_MAX)

   927 	{

   928 		return 0;

   929 	}

   931 	int client = m_UserIdLookUp[userid];

   933 	/* Verify the userid.  The cache can get messed up with older

   934 	 * Valve engines.  :TODO: If this gets fixed, do an old engine

   935 	 * check before invoking this backwards compat code.

   936 	 */

   937 	if (client)

   938 	{

   939 		CPlayer *player = GetPlayerByIndex(client);

   940 		if (player && player->IsConnected())

   941 		{

   942 			int realUserId = engine->GetPlayerUserId(player->GetEdict());

   943 			if (realUserId == userid)

   944 			{

   945 				return client;

   946 			}

   947 		}

   948 	}

   950 	/* If we can't verify the userid, we have to do a manual loop */

   951 	CPlayer *player;

   952 	for (int i = 1; i <= m_maxClients; i++)

   953 	{

   954 		player = GetPlayerByIndex(i);

   955 		if (!player || !player->IsConnected())

   956 		{

   957 			continue;

   958 		}

   959 		if (engine->GetPlayerUserId(player->GetEdict()) == userid)

   960 		{

   961 			m_UserIdLookUp[userid] = i;

   962 			return i;

   963 		}

   964 	}

   966 	return 0;

   967 }

   969 void PlayerManager::AddClientListener(IClientListener *listener)

   970 {

   971 	m_hooks.push_back(listener);

   972 }

   974 void PlayerManager::RemoveClientListener(IClientListener *listener)

   975 {

   976 	m_hooks.remove(listener);

   977 }

   979 IGamePlayer *PlayerManager::GetGamePlayer(edict_t *pEdict)

   980 {

   981 	int index = IndexOfEdict(pEdict);

   982 	return GetGamePlayer(index);

   983 }

   985 IGamePlayer *PlayerManager::GetGamePlayer(int client)

   986 {

   987 	return GetPlayerByIndex(client);

   988 }

   990 void PlayerManager::ClearAdminId(AdminId id)

   991 {

   992 	for (int i=1; i<=m_maxClients; i++)

   993 	{

   994 		if (m_Players[i].m_Admin == id)

   995 		{

   996 			m_Players[i].DumpAdmin(true);

   997 		}

   998 	}

   999 }

  1001 void PlayerManager::ClearAllAdmins()

  1002 {

  1003 	for (int i=1; i<=m_maxClients; i++)

  1004 	{

  1005 		m_Players[i].DumpAdmin(true);

  1006 	}

  1007 }

  1009 const char *PlayerManager::GetPassInfoVar()

  1010 {

  1011 	return m_PassInfoVar.c_str();

  1012 }

  1014 void PlayerManager::RecheckAnyAdmins()

  1015 {

  1016 	for (int i=1; i<=m_maxClients; i++)

  1017 	{

  1018 		if (m_Players[i].IsInGame() && m_Players[i].IsAuthorized())

  1019 		{

  1020 			m_Players[i].DoBasicAdminChecks();

  1021 		}

  1022 	}

  1023 }

  1025 unsigned int PlayerManager::GetReplyTo()

  1026 {

  1027 	return g_ChatTriggers.GetReplyTo();

  1028 }

  1030 unsigned int PlayerManager::SetReplyTo(unsigned int reply)

  1031 {

  1032 	return g_ChatTriggers.SetReplyTo(reply);

  1033 }

  1035 int PlayerManager::FilterCommandTarget(IGamePlayer *pAdmin, IGamePlayer *pTarget, int flags)

  1036 {

  1037 	return InternalFilterCommandTarget((CPlayer *)pAdmin, (CPlayer *)pTarget, flags);

  1038 }

  1040 void PlayerManager::RegisterCommandTargetProcessor(ICommandTargetProcessor *pHandler)

  1041 {

  1042 	target_processors.push_back(pHandler);

  1043 }

  1045 void PlayerManager::UnregisterCommandTargetProcessor(ICommandTargetProcessor *pHandler)

  1046 {

  1047 	target_processors.remove(pHandler);

  1048 }

  1050 void PlayerManager::InvalidatePlayer(CPlayer *pPlayer)

  1051 {

  1052 	/**

  1053 	* Remove client from auth queue if necessary

  1054 	*/

  1055 	if (!pPlayer->IsAuthorized())

  1056 	{

  1057 		for (unsigned int i=1; i<=m_AuthQueue[0]; i++)

  1058 		{

  1059 			if (m_AuthQueue[i] == (unsigned)pPlayer->m_iIndex)

  1060 			{

  1061 				/* Move everything ahead of us back by one */

  1062 				for (unsigned int j=i+1; j<=m_AuthQueue[0]; j++)

  1063 				{

  1064 					m_AuthQueue[j-1] = m_AuthQueue[j];

  1065 				}

  1066 				/* Remove us and break */

  1067 				m_AuthQueue[0]--;

  1068 				break;

  1069 			}

  1070 		}

  1071 	}

  1073 	m_UserIdLookUp[engine->GetPlayerUserId(pPlayer->m_pEdict)] = 0;

  1074 	pPlayer->Disconnect();

  1075 }

  1077 int PlayerManager::InternalFilterCommandTarget(CPlayer *pAdmin, CPlayer *pTarget, int flags)

  1078 {

  1079 	if ((flags & COMMAND_FILTER_CONNECTED) == COMMAND_FILTER_CONNECTED

  1080 		&& !pTarget->IsConnected())

  1081 	{

  1082 		return COMMAND_TARGET_NONE;

  1083 	}

  1084 	else if ((flags & COMMAND_FILTER_CONNECTED) != COMMAND_FILTER_CONNECTED &&

  1085 		!pTarget->IsInGame())

  1086 	{

  1087 		return COMMAND_TARGET_NOT_IN_GAME;

  1088 	}

  1090 	if ((flags & COMMAND_FILTER_NO_BOTS) == COMMAND_FILTER_NO_BOTS

  1091 		&& pTarget->IsFakeClient())

  1092 	{

  1093 		return COMMAND_TARGET_NOT_HUMAN;

  1094 	}

  1096 	if (pAdmin != NULL)

  1097 	{

  1098 		if ((flags & COMMAND_FILTER_NO_IMMUNITY) != COMMAND_FILTER_NO_IMMUNITY

  1099 			&& !g_Admins.CanAdminTarget(pAdmin->GetAdminId(), pTarget->GetAdminId()))

  1100 		{

  1101 			return COMMAND_TARGET_IMMUNE;

  1102 		}

  1103 	}

  1105 	if ((flags & COMMAND_FILTER_ALIVE) == COMMAND_FILTER_ALIVE

  1106 		&& pTarget->GetLifeState() != PLAYER_LIFE_ALIVE)

  1107 	{

  1108 		return COMMAND_TARGET_NOT_ALIVE;

  1109 	}

  1111 	if ((flags & COMMAND_FILTER_DEAD) == COMMAND_FILTER_DEAD

  1112 		&& pTarget->GetLifeState() != PLAYER_LIFE_DEAD)

  1113 	{

  1114 		return COMMAND_TARGET_NOT_DEAD;

  1115 	}

  1117 	return COMMAND_TARGET_VALID;

  1118 }

  1120 void PlayerManager::ProcessCommandTarget(cmd_target_info_t *info)

  1121 {

  1122 	CPlayer *pTarget, *pAdmin;

  1123 	int max_clients, total = 0;

  1125 	max_clients = GetMaxClients();

  1127 	if (info->max_targets < 1)

  1128 	{

  1129 		info->reason = COMMAND_TARGET_NONE;

  1130 		info->num_targets = 0;

  1131 	}

  1133 	if (info->admin == 0)

  1134 	{

  1135 		pAdmin = NULL;

  1136 	}

  1137 	else

  1138 	{

  1139 		pAdmin = GetPlayerByIndex(info->admin);

  1140 	}

  1142 	if (info->pattern[0] == '#')

  1143 	{

  1144 		int userid = atoi(&info->pattern[1]);

  1145 		int client = GetClientOfUserId(userid);

  1147 		/* See if a valid userid matched */

  1148 		if (client > 0)

  1149 		{

  1150 			IGamePlayer *pTarget = GetPlayerByIndex(client);

  1151 			if (pTarget != NULL)

  1152 			{

  1153 				if ((info->reason = FilterCommandTarget(pAdmin, pTarget, info->flags)) == COMMAND_TARGET_VALID)

  1154 				{

  1155 					info->targets[0] = client;

  1156 					info->num_targets = 1;

  1157 					strncopy(info->target_name, pTarget->GetName(), info->target_name_maxlength);

  1158 					info->target_name_style = COMMAND_TARGETNAME_RAW;

  1159 				}

  1160 				else

  1161 				{

  1162 					info->num_targets = 0;

  1163 				}

  1164 				return;

  1165 			}

  1166 		}

  1168 		/* Do we need to look for a steam id? */

  1169 		if (strncmp(&info->pattern[1], "STEAM_", 6) == 0)

  1170 		{

  1171 			size_t p, len;

  1172 			char new_pattern[256];

  1174 			strcpy(new_pattern, "STEAM_");

  1175 			len = strlen(&info->pattern[7]);

  1176 			for (p = 0; p < len; p++)

  1177 			{

  1178 				new_pattern[6 + p] = info->pattern[7 + p];

  1179 				if (new_pattern[6 + p] == '_')

  1180 				{

  1181 					new_pattern[6 + p] = ':';

  1182 				}

  1183 			}

  1184 			new_pattern[6 + p] = '\0';

  1186 			for (int i = 1; i <= max_clients; i++)

  1187 			{

  1188 				if ((pTarget = GetPlayerByIndex(i)) == NULL)

  1189 				{

  1190 					continue;

  1191 				}

  1192 				if (!pTarget->IsConnected() || !pTarget->IsAuthorized())

  1193 				{

  1194 					continue;

  1195 				}

  1196 				if (strcmp(pTarget->GetAuthString(), new_pattern) == 0)

  1197 				{

  1198 					if ((info->reason = FilterCommandTarget(pAdmin, pTarget, info->flags))

  1199 						== COMMAND_TARGET_VALID)

  1200 					{

  1201 						info->targets[0] = i;

  1202 						info->num_targets = 1;

  1203 						strncopy(info->target_name, pTarget->GetName(), info->target_name_maxlength);

  1204 						info->target_name_style = COMMAND_TARGETNAME_RAW;

  1205 					}

  1206 					else

  1207 					{

  1208 						info->num_targets = 0;

  1209 					}

  1210 					return;

  1211 				}

  1212 			}

  1213 		}

  1215 		/* See if an exact name matches */

  1216 		for (int i = 1; i <= max_clients; i++)

  1217 		{

  1218 			if ((pTarget = GetPlayerByIndex(i)) == NULL)

  1219 			{

  1220 				continue;

  1221 			}

  1222 			if  (!pTarget->IsConnected())

  1223 			{

  1224 				continue;

  1225 			}

  1226 			if (strcmp(pTarget->GetName(), &info->pattern[1]) == 0)

  1227 			{

  1228 				if ((info->reason = FilterCommandTarget(pAdmin, pTarget, info->flags))

  1229 					== COMMAND_TARGET_VALID)

  1230 				{

  1231 					info->targets[0] = i;

  1232 					info->num_targets = 1;

  1233 					strncopy(info->target_name, pTarget->GetName(), info->target_name_maxlength);

  1234 					info->target_name_style = COMMAND_TARGETNAME_RAW;

  1235 				}

  1236 				else

  1237 				{

  1238 					info->num_targets = 0;

  1239 				}

  1240 				return;

  1241 			}

  1242 		}

  1243 	}

  1245 	if (strcmp(info->pattern, "@me") == 0 && info->admin != 0)

  1246 	{

  1247 		info->reason = FilterCommandTarget(pAdmin, pAdmin, info->flags);

  1248 		if (info->reason == COMMAND_TARGET_VALID)

  1249 		{

  1250 			info->targets[0] = info->admin;

  1251 			info->num_targets = 1;

  1252 			strncopy(info->target_name, pAdmin->GetName(), info->target_name_maxlength);

  1253 			info->target_name_style = COMMAND_TARGETNAME_RAW;

  1254 		}

  1255 		else

  1256 		{

  1257 			info->num_targets = 0;

  1258 		}

  1259 		return;

  1260 	}

  1262 	if ((info->flags & COMMAND_FILTER_NO_MULTI) != COMMAND_FILTER_NO_MULTI)

  1263 	{

  1264 		bool is_multi = false;

  1265 		bool bots_only = false;

  1266 		int skip_client = -1;

  1268 		if (strcmp(info->pattern, "@all") == 0)

  1269 		{

  1270 			is_multi = true;

  1271 			strncopy(info->target_name, "all players", info->target_name_maxlength);

  1272 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1273 		}

  1274 		else if (strcmp(info->pattern, "@dead") == 0)

  1275 		{

  1276 			is_multi = true;

  1277 			if ((info->flags & COMMAND_FILTER_ALIVE) == COMMAND_FILTER_ALIVE)

  1278 			{

  1279 				info->num_targets = 0;

  1280 				info->reason = COMMAND_TARGET_NOT_ALIVE;

  1281 				return;

  1282 			}

  1283 			info->flags |= COMMAND_FILTER_DEAD;

  1284 			strncopy(info->target_name, "all dead players", info->target_name_maxlength);

  1285 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1286 		}

  1287 		else if (strcmp(info->pattern, "@alive") == 0)

  1288 		{

  1289 			is_multi = true;

  1290 			if ((info->flags & COMMAND_FILTER_DEAD) == COMMAND_FILTER_DEAD)

  1291 			{

  1292 				info->num_targets = 0;

  1293 				info->reason = COMMAND_TARGET_NOT_DEAD;

  1294 				return;

  1295 			}

  1296 			strncopy(info->target_name, "all alive players", info->target_name_maxlength);

  1297 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1298 			info->flags |= COMMAND_FILTER_ALIVE;

  1299 		}

  1300 		else if (strcmp(info->pattern, "@bots") == 0)

  1301 		{

  1302 			is_multi = true;

  1303 			if ((info->flags & COMMAND_FILTER_NO_BOTS) == COMMAND_FILTER_NO_BOTS)

  1304 			{

  1305 				info->num_targets = 0;

  1306 				info->reason = COMMAND_FILTER_NO_BOTS;

  1307 				return;

  1308 			}

  1309 			strncopy(info->target_name, "all bots", info->target_name_maxlength);

  1310 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1311 			bots_only = true;

  1312 		}

  1313 		else if (strcmp(info->pattern, "@humans") == 0)

  1314 		{

  1315 			is_multi = true;

  1316 			strncopy(info->target_name, "all humans", info->target_name_maxlength);

  1317 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1318 			info->flags |= COMMAND_FILTER_NO_BOTS;

  1319 		}

  1320 		else if (strcmp(info->pattern, "@!me") == 0)

  1321 		{

  1322 			is_multi = true;

  1323 			strncopy(info->target_name, "all players", info->target_name_maxlength);

  1324 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1325 			skip_client = info->admin;

  1326 		}

  1328 		if (is_multi)

  1329 		{

  1330 			for (int i = 1; i <= max_clients && total < info->max_targets; i++)

  1331 			{

  1332 				if ((pTarget = GetPlayerByIndex(i)) == NULL)

  1333 				{

  1334 					continue;

  1335 				}

  1336 				if (FilterCommandTarget(pAdmin, pTarget, info->flags) > 0)

  1337 				{

  1338 					if ((!bots_only || pTarget->IsFakeClient())

  1339 						&& skip_client != i)

  1340 					{

  1341 						info->targets[total++] = i;

  1342 					}

  1343 				}

  1344 			}

  1346 			info->num_targets = total;

  1347 			info->reason = (info->num_targets) ? COMMAND_TARGET_VALID : COMMAND_TARGET_EMPTY_FILTER;

  1348 			return;

  1349 		}

  1350 	}

  1352 	List<ICommandTargetProcessor *>::iterator iter;

  1353 	for (iter = target_processors.begin(); iter != target_processors.end(); iter++)

  1354 	{

  1355 		ICommandTargetProcessor *pProcessor = (*iter);

  1356 		if (pProcessor->ProcessCommandTarget(info))

  1357 		{

  1358 			return;

  1359 		}

  1360 	}

  1362 	/* Check partial names */

  1363 	int found_client = 0;

  1364 	CPlayer *pFoundClient = NULL;

  1365 	for (int i = 1; i <= max_clients; i++)

  1366 	{

  1367 		if ((pTarget = GetPlayerByIndex(i)) == NULL)

  1368 		{

  1369 			continue;

  1370 		}

  1372 		if (logicore.stristr(pTarget->GetName(), info->pattern) != NULL)

  1373 		{

  1374 			if (found_client)

  1375 			{

  1376 				info->num_targets = 0;

  1377 				info->reason = COMMAND_TARGET_AMBIGUOUS;

  1378 				return;

  1379 			}

  1380 			else

  1381 			{

  1382 				found_client = i;

  1383 				pFoundClient = pTarget;

  1384 			}

  1385 		}

  1386 	}

  1388 	if (found_client)

  1389 	{

  1390 		if ((info->reason = FilterCommandTarget(pAdmin, pFoundClient, info->flags))

  1391 			== COMMAND_TARGET_VALID)

  1392 		{

  1393 			info->targets[0] = found_client;

  1394 			info->num_targets = 1;

  1395 			strncopy(info->target_name, pFoundClient->GetName(), info->target_name_maxlength);

  1396 			info->target_name_style = COMMAND_TARGETNAME_RAW;

  1397 		}

  1398 		else

  1399 		{

  1400 			info->num_targets = 0;

  1401 		}

  1402 	}

  1403 	else

  1404 	{

  1405 		info->num_targets = 0;

  1406 		info->reason = COMMAND_TARGET_NONE;

  1407 	}

  1408 }

  1410 void PlayerManager::OnSourceModMaxPlayersChanged( int newvalue )

  1411 {

  1412 	m_maxClients = newvalue;

  1413 }

  1415 void PlayerManager::MaxPlayersChanged( int newvalue /*= -1*/ )

  1416 {

  1417 	if (!m_FirstPass)

  1418 	{

  1419 		return;

  1420 	}

  1422 	if (newvalue == -1)

  1423 	{

  1424 		newvalue = gpGlobals->maxClients;

  1425 	}

  1427 	if (newvalue == MaxClients())

  1428 	{

  1429 		return;

  1430 	}

  1432 	/* Notify the rest of core */

  1433 	SMGlobalClass *pBase = SMGlobalClass::head;

  1434 	while (pBase)

  1435 	{

  1436 		pBase->OnSourceModMaxPlayersChanged(newvalue);

  1437 		pBase = pBase->m_pGlobalClassNext;

  1438 	}

  1440 	/* Notify Extensions */

  1441 	List<IClientListener *>::iterator iter;

  1442 	IClientListener *pListener = NULL;

  1443 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

  1444 	{

  1445 		pListener = (*iter);

  1446 		if (pListener->GetClientListenerVersion() >= 8)

  1447 		{

  1448 			pListener->OnMaxPlayersChanged(newvalue);

  1449 		}

  1450 	}

  1451 }

  1453 int PlayerManager::GetClientFromSerial(unsigned int serial)

  1454 {

  1455 	serial_t s;

  1456 	s.value = serial;

  1458 	int client = s.bits.index;

  1460 	IGamePlayer *pPlayer = GetGamePlayer(client);

  1462 	if (!pPlayer)

  1463 	{

  1464 		return 0;

  1465 	}

  1467 	if (serial == pPlayer->GetSerial())

  1468 	{

  1469 		return client;

  1470 	}

  1472 	return 0;

  1473 }

  1475 #if SOURCE_ENGINE >= SE_ORANGEBOX

  1476 void CmdMaxplayersCallback(const CCommand &command)

  1477 {

  1478 #else

  1479 void CmdMaxplayersCallback()

  1480 {

  1481 #endif

  1483 	g_Players.MaxPlayersChanged();

  1484 }

  1487 /*******************

  1488  *** PLAYER CODE ***

  1489  *******************/

  1491 CPlayer::CPlayer()

  1492 {

  1493 	m_IsConnected = false;

  1494 	m_IsInGame = false;

  1495 	m_IsAuthorized = false;

  1496 	m_pEdict = NULL;

  1497 	m_Admin = INVALID_ADMIN_ID;

  1498 	m_TempAdmin = false;

  1499 	m_Info = NULL;

  1500 	m_bAdminCheckSignalled = false;

  1501 	m_UserId = -1;

  1502 	m_bIsInKickQueue = false;

  1503 	m_LastPassword.clear();

  1504 	m_LangId = SOURCEMOD_LANGUAGE_ENGLISH;

  1505 	m_bFakeClient = false;

  1506 	m_bIsSourceTV = false;

  1507 	m_bIsReplay = false;

  1508 	m_Serial.value = -1;

  1509 }

  1511 void CPlayer::Initialize(const char *name, const char *ip, edict_t *pEntity)

  1512 {

  1513 	m_IsConnected = true;

  1514 	m_Name.assign(name);

  1515 	m_Ip.assign(ip);

  1516 	m_pEdict = pEntity;

  1517 	m_iIndex = IndexOfEdict(pEntity);

  1518 	m_LangId = translator->GetServerLanguage();

  1520 	m_Serial.bits.index = m_iIndex;

  1521 	m_Serial.bits.serial = g_PlayerSerialCount++;

  1523 	char ip2[24], *ptr;

  1524 	strncopy(ip2, ip, sizeof(ip2));

  1525 	if ((ptr = strchr(ip2, ':')) != NULL)

  1526 	{

  1527 		*ptr = '\0';

  1528 	}

  1529 	m_IpNoPort.assign(ip2);

  1530 }

  1532 void CPlayer::Connect()

  1533 {

  1534 	if (m_IsInGame)

  1535 	{

  1536 		return;

  1537 	}

  1539 	m_IsInGame = true;

  1541 	const char *var = g_Players.GetPassInfoVar();

  1542 	int client = IndexOfEdict(m_pEdict);

  1543 	if (var[0] != '\0')

  1544 	{

  1545 		const char *pass = engine->GetClientConVarValue(client, var);

  1546 		m_LastPassword.assign(pass ? pass : "");

  1547 	}

  1548 	else

  1549 	{

  1550 		m_LastPassword.assign("");

  1551 	}

  1552 }

  1554 void CPlayer::Authorize(const char *steamid)

  1555 {

  1556 	if (m_IsAuthorized)

  1557 	{

  1558 		return;

  1559 	}

  1561 	m_IsAuthorized = true;

  1562 	m_AuthID.assign(steamid);

  1563 }

  1565 void CPlayer::Disconnect()

  1566 {

  1567 	DumpAdmin(false);

  1568 	m_IsConnected = false;

  1569 	m_IsInGame = false;

  1570 	m_IsAuthorized = false;

  1571 	m_Name.clear();

  1572 	m_Ip.clear();

  1573 	m_AuthID.clear();

  1574 	m_pEdict = NULL;

  1575 	m_Info = NULL;

  1576 	m_bAdminCheckSignalled = false;

  1577 	m_UserId = -1;

  1578 	m_bIsInKickQueue = false;

  1579 	m_bFakeClient = false;

  1580 	m_bIsSourceTV = false;

  1581 	m_bIsReplay = false;

  1582 	m_Serial.value = -1;

  1583 }

  1585 void CPlayer::SetName(const char *name)

  1586 {

  1587 	m_Name.assign(name);

  1588 }

  1590 const char *CPlayer::GetName()

  1591 {

  1592 	if (m_Info && m_pEdict->GetUnknown())

  1593 	{

  1594 		return m_Info->GetName();

  1595 	}

  1597 	return m_Name.c_str();

  1598 }

  1600 const char *CPlayer::GetIPAddress()

  1601 {

  1602 	return m_Ip.c_str();

  1603 }

  1605 const char *CPlayer::GetAuthString()

  1606 {

  1607 	return m_AuthID.c_str();

  1608 }

  1610 edict_t *CPlayer::GetEdict()

  1611 {

  1612 	return m_pEdict;

  1613 }

  1615 bool CPlayer::IsInGame()

  1616 {

  1617 	return m_IsInGame && (m_pEdict->GetUnknown() != NULL);

  1618 }

  1620 bool CPlayer::WasCountedAsInGame()

  1621 {

  1622 	return m_IsInGame;

  1623 }

  1625 bool CPlayer::IsConnected()

  1626 {

  1627 	return m_IsConnected;

  1628 }

  1630 bool CPlayer::IsAuthorized()

  1631 {

  1632 	return m_IsAuthorized;

  1633 }

  1635 IPlayerInfo *CPlayer::GetPlayerInfo()

  1636 {

  1637 	if (m_pEdict->GetUnknown())

  1638 	{

  1639 		return m_Info;

  1640 	}

  1642 	return NULL;

  1643 }

  1645 bool CPlayer::IsFakeClient()

  1646 {

  1647 	return m_bFakeClient;

  1648 }

  1650 bool CPlayer::IsSourceTV() const

  1651 {

  1652 	return m_bIsSourceTV;

  1653 }

  1655 bool CPlayer::IsReplay() const

  1656 {

  1657 	return m_bIsReplay;

  1658 }

  1660 void CPlayer::SetAdminId(AdminId id, bool temporary)

  1661 {

  1662 	if (!m_IsConnected)

  1663 	{

  1664 		return;

  1665 	}

  1667 	DumpAdmin(false);

  1669 	m_Admin = id;

  1670 	m_TempAdmin = temporary;

  1671 }

  1673 AdminId CPlayer::GetAdminId()

  1674 {

  1675 	return m_Admin;

  1676 }

  1678 void CPlayer::DumpAdmin(bool deleting)

  1679 {

  1680 	if (m_Admin != INVALID_ADMIN_ID)

  1681 	{

  1682 		if (m_TempAdmin && !deleting)

  1683 		{

  1684 			g_Admins.InvalidateAdmin(m_Admin);

  1685 		}

  1686 		m_Admin = INVALID_ADMIN_ID;

  1687 		m_TempAdmin = false;

  1688 	}

  1689 }

  1691 void CPlayer::Kick(const char *str)

  1692 {

  1693 	MarkAsBeingKicked();

  1694 	INetChannel *pNetChan = static_cast<INetChannel *>(engine->GetPlayerNetInfo(m_iIndex));

  1695 	if (pNetChan == NULL)

  1696 	{

  1697 		/* What does this even mean? Hell if I know. */

  1698 		int userid = GetUserId();

  1699 		if (userid > 0)

  1700 		{

  1701 			char buffer[255];

  1702 			UTIL_Format(buffer, sizeof(buffer), "kickid %d %s\n", userid, str);

  1703 			engine->ServerCommand(buffer);

  1704 		}

  1705 	}

  1706 	else

  1707 	{

  1708 		IClient *pClient = static_cast<IClient *>(pNetChan->GetMsgHandler());

  1709 		pClient->Disconnect("%s", str);

  1710 	}

  1711 }

  1713 void CPlayer::Authorize_Post()

  1714 {

  1715 	if (m_IsInGame)

  1716 	{

  1717 		DoPostConnectAuthorization();

  1718 	}

  1719 }

  1721 void CPlayer::DoPostConnectAuthorization()

  1722 {

  1723 	bool delay = false;

  1725 	List<IClientListener *>::iterator iter;

  1726 	for (iter = g_Players.m_hooks.begin();

  1727 		 iter != g_Players.m_hooks.end();

  1728 		 iter++)

  1729 	{

  1730 		IClientListener *pListener = (*iter);

  1731 #if defined MIN_API_FOR_ADMINCALLS

  1732 		if (pListener->GetClientListenerVersion() < MIN_API_FOR_ADMINCALLS)

  1733 		{

  1734 			continue;

  1735 		}

  1736 #endif

  1737 		if (!pListener->OnClientPreAdminCheck(m_iIndex))

  1738 		{

  1739 			delay = true;

  1740 		}

  1741 	}

  1743 	cell_t result = 0;

  1744 	PreAdminCheck->PushCell(m_iIndex);

  1745 	PreAdminCheck->Execute(&result);

  1747 	/* Defer, for better or worse */

  1748 	if (delay || (ResultType)result >= Pl_Handled)

  1749 	{

  1750 		return;

  1751 	}

  1753 	/* Sanity check */

  1754 	if (!IsConnected())

  1755 	{

  1756 		return;

  1757 	}

  1759 	/* Otherwise, go ahead and do admin checks */

  1760 	DoBasicAdminChecks();

  1762 	/* Send the notification out */

  1763 	NotifyPostAdminChecks();

  1764 }

  1766 bool CPlayer::RunAdminCacheChecks()

  1767 {

  1768 	AdminId old_id = GetAdminId();

  1770 	DoBasicAdminChecks();

  1772 	return (GetAdminId() != old_id);

  1773 }

  1775 void CPlayer::NotifyPostAdminChecks()

  1776 {

  1777 	if (m_bAdminCheckSignalled)

  1778 	{

  1779 		return;

  1780 	}

  1782 	/* Block beforehand so they can't double-call */

  1783 	m_bAdminCheckSignalled = true;

  1785 	List<IClientListener *>::iterator iter;

  1786 	for (iter = g_Players.m_hooks.begin();

  1787 		iter != g_Players.m_hooks.end();

  1788 		iter++)

  1789 	{

  1790 		IClientListener *pListener = (*iter);

  1791 #if defined MIN_API_FOR_ADMINCALLS

  1792 		if (pListener->GetClientListenerVersion() < MIN_API_FOR_ADMINCALLS)

  1793 		{

  1794 			continue;

  1795 		}

  1796 #endif

  1797 		pListener->OnClientPostAdminCheck(m_iIndex);

  1798 	}

  1800 	PostAdminFilter->PushCell(m_iIndex);

  1801 	PostAdminFilter->Execute(NULL);

  1803 	PostAdminCheck->PushCell(m_iIndex);

  1804 	PostAdminCheck->Execute(NULL);

  1805 }

  1807 void CPlayer::DoBasicAdminChecks()

  1808 {

  1809 	if (GetAdminId() != INVALID_ADMIN_ID)

  1810 	{

  1811 		return;

  1812 	}

  1814 	/* First check the name */

  1815 	AdminId id;

  1816 	int client = IndexOfEdict(m_pEdict);

  1818 	if ((id = g_Admins.FindAdminByIdentity("name", GetName())) != INVALID_ADMIN_ID)

  1819 	{

  1820 		if (!g_Players.CheckSetAdminName(client, this, id))

  1821 		{

  1822 			int userid = engine->GetPlayerUserId(m_pEdict);

  1823 			g_Timers.CreateTimer(&s_KickPlayerTimer, 0.1f, (void *)userid, 0);

  1824 		}

  1825 		return;

  1826 	}

  1828 	/* Check IP */

  1829 	if ((id = g_Admins.FindAdminByIdentity("ip", m_IpNoPort.c_str())) != INVALID_ADMIN_ID)

  1830 	{

  1831 		if (g_Players.CheckSetAdmin(client, this, id))

  1832 		{

  1833 			return;

  1834 		}

  1835 	}

  1837 	/* Check steam id */

  1838 	if ((id = g_Admins.FindAdminByIdentity("steam", m_AuthID.c_str())) != INVALID_ADMIN_ID)

  1839 	{

  1840 		if (g_Players.CheckSetAdmin(client, this, id))

  1841 		{

  1842 			return;

  1843 		}

  1844 	}

  1845 }

  1847 unsigned int CPlayer::GetLanguageId()

  1848 {

  1849 	return m_LangId;

  1850 }

  1852 void CPlayer::SetLanguageId(unsigned int id)

  1853 {

  1854 	m_LangId = id;

  1855 }

  1857 int CPlayer::GetUserId()

  1858 {

  1859 	if (m_UserId == -1)

  1860 	{

  1861 		m_UserId = engine->GetPlayerUserId(GetEdict());

  1862 	}

  1864 	return m_UserId;

  1865 }

  1867 bool CPlayer::IsInKickQueue()

  1868 {

  1869 	return m_bIsInKickQueue;

  1870 }

  1872 void CPlayer::MarkAsBeingKicked()

  1873 {

  1874 	m_bIsInKickQueue = true;

  1875 }

  1877 int CPlayer::GetLifeState()

  1878 {

  1879 	if (lifestate_offset == -1)

  1880 	{

  1881 		if (!g_pGameConf->GetOffset("m_lifeState", &lifestate_offset))

  1882 		{

  1883 			lifestate_offset = -2;

  1884 		}

  1885 	}

  1887 	if (lifestate_offset < 0)

  1888 	{

  1889 		IPlayerInfo *info = GetPlayerInfo();

  1890 		if (info == NULL)

  1891 		{

  1892 			return PLAYER_LIFE_UNKNOWN;

  1893 		}

  1894 		return info->IsDead() ? PLAYER_LIFE_DEAD : PLAYER_LIFE_ALIVE;

  1895 	}

  1897 	if (m_pEdict == NULL)

  1898 	{

  1899 		return PLAYER_LIFE_UNKNOWN;

  1900 	}

  1902 	CBaseEntity *pEntity;

  1903 	IServerUnknown *pUnknown = m_pEdict->GetUnknown();

  1904 	if (pUnknown == NULL || (pEntity = pUnknown->GetBaseEntity()) == NULL)

  1905 	{

  1906 		return PLAYER_LIFE_UNKNOWN;

  1907 	}

  1909 	if (*((uint8_t *)pEntity + lifestate_offset) == LIFE_ALIVE)

  1910 	{

  1911 		return PLAYER_LIFE_ALIVE;

  1912 	}

  1913 	else

  1914 	{

  1915 		return PLAYER_LIFE_DEAD;

  1916 	}

  1917 }

  1919 unsigned int CPlayer::GetSerial()

  1920 {

  1921 	return m_Serial.value;

  1922 }

author	Nicholas Hastings <skamonkey@gmail.com>
	Sat Feb 25 15:09:56 2012 -0500 (2012-02-25)
changeset 3460	ccd11f0c5372
parent 3436	d9ef0c2068d7
child 3502	2c1c30b50acc
permissions	-rw-r--r--