sourcemod-central: core/PlayerManager.cpp@72a4e13eb106

     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;

   115 	m_UserIdLookUp = new int[USHRT_MAX+1];

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

   117 }

   119 PlayerManager::~PlayerManager()

   120 {

   121 	g_NumPlayersToAuth = NULL;

   123 	delete [] m_AuthQueue;

   124 	delete [] m_UserIdLookUp;

   125 }

   127 void PlayerManager::OnSourceModAllInitialized()

   128 {

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

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

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

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

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

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

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

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

   138 	g_ShareSys.AddInterface(NULL, this);

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

   141 	ParamType p2[] = {Param_Cell};

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

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

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

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

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

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

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

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

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

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

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

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

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

   158 	m_bIsListenServer = !engine->IsDedicatedServer();

   159 	m_ListenClient = 0;

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

   162 	if (pCmd != NULL)

   163 	{

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

   165 		maxplayersCmd = pCmd;

   166 	}

   167 }

   169 void PlayerManager::OnSourceModShutdown()

   170 {

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

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

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

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

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

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

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

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

   180 	/* Release forwards */

   181 	g_Forwards.ReleaseForward(m_clconnect);

   182 	g_Forwards.ReleaseForward(m_clconnect_post);

   183 	g_Forwards.ReleaseForward(m_clputinserver);

   184 	g_Forwards.ReleaseForward(m_cldisconnect);

   185 	g_Forwards.ReleaseForward(m_cldisconnect_post);

   186 	g_Forwards.ReleaseForward(m_clcommand);

   187 	g_Forwards.ReleaseForward(m_clinfochanged);

   188 	g_Forwards.ReleaseForward(m_clauth);

   189 	g_Forwards.ReleaseForward(m_onActivate);

   190 	g_Forwards.ReleaseForward(m_onActivate2);

   192 	g_Forwards.ReleaseForward(PreAdminCheck);

   193 	g_Forwards.ReleaseForward(PostAdminCheck);

   194 	g_Forwards.ReleaseForward(PostAdminFilter);

   196 	delete [] m_Players;

   198 	if (maxplayersCmd != NULL)

   199 	{

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

   201 	}

   202 }

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

   205 												 const char *value,

   206 												 ConfigSource source,

   207 												 char *error,

   208 												 size_t maxlength)

   209 {

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

   211 	{

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

   213 		{

   214 			m_PassInfoVar.assign(value);

   215 		}

   216 		return ConfigResult_Accept;

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

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

   219 		{

   220 			m_QueryLang = true;

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

   222 			m_QueryLang = false;

   223 		} else {

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

   225 			return ConfigResult_Reject;

   226 		}

   227 		return ConfigResult_Accept;

   228 	}

   229 	return ConfigResult_Ignore;

   230 }

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

   233 {

   234 	int maxClients = gpGlobals->maxClients;

   235 	if (!m_FirstPass)

   236 	{

   237 		/* Initialize all players */

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

   241 		m_PlayerCount = 0;

   242 		m_Players = new CPlayer[ABSOLUTE_PLAYER_LIMIT + 1];

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

   244 		m_FirstPass = true;

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

   248 		g_NumPlayersToAuth = &m_AuthQueue[0];

   250 		g_PluginSys.SyncMaxClients(maxClients);

   251 	}

   252 	g_Extensions.CallOnCoreMapStart(pEdictList, edictCount, maxClients);

   253 	m_onActivate->Execute(NULL);

   254 	m_onActivate2->Execute(NULL);

   256 	List<IClientListener *>::iterator iter;

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

   258 	{

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

   260 		{

   261 			(*iter)->OnServerActivated(maxClients);

   262 		}

   263 	}

   265 	g_OnMapStarted = true;

   267 	SMGlobalClass *cls = SMGlobalClass::head;

   268 	while (cls)

   269 	{

   270 		cls->OnSourceModLevelActivated();

   271 		cls = cls->m_pGlobalClassNext;

   272 	}

   274 	SM_ExecuteAllConfigs();

   275 }

   277 bool PlayerManager::IsServerActivated()

   278 {

   279 	return m_FirstPass;

   280 }

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

   283 {

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

   285 	if (password != NULL)

   286 	{

   287 		if (m_PassInfoVar.size() < 1)

   288 		{

   289 			return false;

   290 		}

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

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

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

   295 		{

   296 			return false;

   297 		}

   298 	}

   300 	pPlayer->SetAdminId(id, false);

   302 	return true;

   303 }

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

   306 {

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

   308 	if (password == NULL)

   309 	{

   310 		return false;

   311 	}

   313 	if (m_PassInfoVar.size() < 1)

   314 	{

   315 		return false;

   316 	}

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

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

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

   321 	{

   322 		return false;

   323 	}

   325 	pPlayer->SetAdminId(id, false);

   327 	return true;

   328 }

   330 void PlayerManager::RunAuthChecks()

   331 {

   332 	CPlayer *pPlayer;

   333 	const char *authstr;

   334 	unsigned int removed = 0;

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

   336 	{

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

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

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

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

   341 		{

   342 			/* Set authorization */

   343 			pPlayer->Authorize(authstr);

   345 			/* Mark as removed from queue */

   346 			unsigned int client = m_AuthQueue[i];

   347 			m_AuthQueue[i] = 0;

   348 			removed++;

   350 			/* Send to extensions */

   351 			List<IClientListener *>::iterator iter;

   352 			IClientListener *pListener;

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

   354 			{

   355 				pListener = (*iter);

   356 				pListener->OnClientAuthorized(client, authstr);

   357 				if (!pPlayer->IsConnected())

   358 				{

   359 					break;

   360 				}

   361 			}

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

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

   365 			{

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

   367 				m_clauth->PushCell(client);

   368 				m_clauth->PushString(authstr);

   369 				m_clauth->Execute(NULL);

   370 			}

   372 			if (pPlayer->IsConnected())

   373 			{

   374 				pPlayer->Authorize_Post();

   375 			}

   376 		}

   377 	}

   379 	/* Clean up the queue */

   380 	if (removed)

   381 	{

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

   383 		if (removed != m_AuthQueue[0])

   384 		{

   385 			unsigned int diff = 0;

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

   387 			{

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

   389 				if (m_AuthQueue[i] == 0)

   390 				{

   391 					/* Increase the differential */

   392 					diff++;

   393 				} else {

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

   395 					assert(i > diff);

   396 					assert(i - diff >= 1);

   397 					/* move this index down */

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

   399 				}

   400 			}

   401 			m_AuthQueue[0] -= removed;

   402 		} else {

   403 			m_AuthQueue[0] = 0;

   404 		}

   405 	}

   406 }

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

   409 {

   410 	int client = IndexOfEdict(pEntity);

   411 	CPlayer *pPlayer = &m_Players[client];

   413 	List<IClientListener *>::iterator iter;

   414 	IClientListener *pListener = NULL;

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

   416 	{

   417 		pListener = (*iter);

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

   419 		{

   420 			return false;

   421 		}

   422 	}

   424 	cell_t res = 1;

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

   427 	m_clconnect->PushCell(client);

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

   429 	m_clconnect->PushCell(maxrejectlen);

   430 	m_clconnect->Execute(&res);

   432 	if (res)

   433 	{

   434 		if (!pPlayer->IsAuthorized())

   435 		{

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

   437 		}

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

   440 	}

   441 	else

   442 	{

   443 		if (!pPlayer->IsFakeClient())

   444 		{

   445 			RETURN_META_VALUE(MRES_SUPERCEDE, false);

   446 		}

   447 	}

   449 	return true;

   450 }

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

   453 {

   454 	int client = IndexOfEdict(pEntity);

   455 	bool orig_value = META_RESULT_ORIG_RET(bool);

   456 	CPlayer *pPlayer = &m_Players[client];

   458 	if (orig_value)

   459 	{

   460 		List<IClientListener *>::iterator iter;

   461 		IClientListener *pListener = NULL;

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

   463 		{

   464 			pListener = (*iter);

   465 			pListener->OnClientConnected(client);

   466 			if (!pPlayer->IsConnected())

   467 			{

   468 				return true;

   469 			}

   470 		}

   472 		if (!pPlayer->IsFakeClient()

   473 			&& m_bIsListenServer

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

   475 		{

   476 			m_ListenClient = client;

   477 		}

   479 		cell_t res;

   480 		m_clconnect_post->PushCell(client);

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

   482 	}

   483 	else

   484 	{

   485 		InvalidatePlayer(pPlayer);

   486 	}

   488 	return true;

   489 }

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

   492 {

   493 	cell_t res;

   494 	int client = IndexOfEdict(pEntity);

   495 	CPlayer *pPlayer = &m_Players[client];

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

   498 	if (!pPlayer->IsConnected())

   499 	{

   500 		/* Run manual connection routines */

   501 		char error[255];

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

   503 		pPlayer->Authorize(authid);

   504 		pPlayer->m_bFakeClient = true;

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

   506 		{

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

   508 			return;

   509 		}

   510 		List<IClientListener *>::iterator iter;

   511 		IClientListener *pListener = NULL;

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

   513 		{

   514 			pListener = (*iter);

   515 			pListener->OnClientConnected(client);

   516 			/* See if bot was kicked */

   517 			if (!pPlayer->IsConnected())

   518 			{

   519 				return;

   520 			}

   521 		}

   523 		cell_t res;

   524 		m_clconnect_post->PushCell(client);

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

   527 		/* Now do authorization */

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

   529 		{

   530 			pListener = (*iter);

   531 			pListener->OnClientAuthorized(client, authid);

   532 		}

   533 		/* Finally, tell plugins */

   534 		if (m_clauth->GetFunctionCount())

   535 		{

   536 			m_clauth->PushCell(client);

   537 			m_clauth->PushString(authid);

   538 			m_clauth->Execute(NULL);

   539 		}

   540 		pPlayer->Authorize_Post();

   541 	}

   543 	if (playerinfo)

   544 	{

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

   546 	}

   548 	/* Get the client's language */

   549 	if (m_QueryLang)

   550 	{

   551 		const char *name;

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

   553 		{

   554 			unsigned int langid;

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

   556 		} else {

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

   558 		}

   559 	}

   561 	pPlayer->Connect();

   562 	m_PlayerCount++;

   564 	List<IClientListener *>::iterator iter;

   565 	IClientListener *pListener = NULL;

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

   567 	{

   568 		pListener = (*iter);

   569 		pListener->OnClientPutInServer(client);

   570 	}

   572 	m_clputinserver->PushCell(client);

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

   575 	if (pPlayer->IsAuthorized())

   576 	{

   577 		pPlayer->DoPostConnectAuthorization();

   578 	}

   579 }

   581 void PlayerManager::OnSourceModLevelEnd()

   582 {

   583 	/* Disconnect all bots still in game */

   584 	int maxClients = gpGlobals->maxClients;

   585 	for (int i=1; i<=maxClients; i++)

   586 	{

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

   588 		{

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

   590 		}

   591 	}

   592 	m_PlayerCount = 0;

   593 }

   595 void PlayerManager::OnClientDisconnect(edict_t *pEntity)

   596 {

   597 	cell_t res;

   598 	int client = IndexOfEdict(pEntity);

   599 	CPlayer *pPlayer = &m_Players[client];

   601 	if (pPlayer->IsConnected())

   602 	{

   603 		m_cldisconnect->PushCell(client);

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

   605 	}

   606 	else

   607 	{

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

   609 		return;

   610 	}

   612 	if (pPlayer->WasCountedAsInGame())

   613 	{

   614 		m_PlayerCount--;

   615 	}

   617 	List<IClientListener *>::iterator iter;

   618 	IClientListener *pListener = NULL;

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

   620 	{

   621 		pListener = (*iter);

   622 		pListener->OnClientDisconnecting(client);

   623 	}

   625 	InvalidatePlayer(pPlayer);

   627 	if (m_ListenClient == client)

   628 	{

   629 		m_ListenClient = 0;

   630 	}

   631 }

   633 void PlayerManager::OnClientDisconnect_Post(edict_t *pEntity)

   634 {

   635 	cell_t res;

   636 	int client = IndexOfEdict(pEntity);

   638 	m_cldisconnect_post->PushCell(client);

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

   641 	List<IClientListener *>::iterator iter;

   642 	IClientListener *pListener = NULL;

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

   644 	{

   645 		pListener = (*iter);

   646 		pListener->OnClientDisconnected(client);

   647 	}

   648 }

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

   651 {

   652 	char buffer[512];

   654 	va_list ap;

   655 	va_start(ap, fmt);

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

   657 	va_end(ap);

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

   660 	{

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

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

   663 	} else {

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

   665 		buffer[len] = '\0';

   666 	}

   668 	engine->ClientPrintf(e, buffer);

   669 }

   671 #if SOURCE_ENGINE >= SE_ORANGEBOX

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

   673 {

   674 #else

   675 void PlayerManager::OnClientCommand(edict_t *pEntity)

   676 {

   677 	CCommand args;

   678 #endif

   679 	int client = IndexOfEdict(pEntity);

   680 	cell_t res = Pl_Continue;

   681 	CPlayer *pPlayer = &m_Players[client];

   683 	if (!pPlayer->IsConnected())

   684 	{

   685 		return;

   686 	}

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

   689 	{

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

   691 		{

   692 			g_PluginSys.ListPluginsToClient(pPlayer, args);

   693 			RETURN_META(MRES_SUPERCEDE);

   694 		}

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

   696 		{

   697 			ClientConsolePrint(pEntity,

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

   699 			ClientConsolePrint(pEntity,

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

   701 			ClientConsolePrint(pEntity,

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

   703 			ClientConsolePrint(pEntity,

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

   705 			ClientConsolePrint(pEntity,

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

   707 			RETURN_META(MRES_SUPERCEDE);

   708 		}

   710 		ClientConsolePrint(pEntity,

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

   712 		ClientConsolePrint(pEntity,

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

   714 		ClientConsolePrint(pEntity,

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

   716 		ClientConsolePrint(pEntity,

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

   718 		RETURN_META(MRES_SUPERCEDE);

   719 	}

   721 	g_HL2.PushCommandStack(&args);

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

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

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

   727 	if (result)

   728 	{

   729 		res = Pl_Handled;

   730 	} else {

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

   732 		if (result)

   733 		{

   734 			res = Pl_Handled;

   735 		}

   736 	}

   738 	if (g_ConsoleDetours.IsEnabled())

   739 	{

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

   741 		if (res2 >= Pl_Stop)

   742 		{

   743 			g_HL2.PopCommandStack();

   744 			RETURN_META(MRES_SUPERCEDE);

   745 		}

   746 		else if (res2 > res)

   747 		{

   748 			res = res2;

   749 		}

   750 	}

   752 	cell_t res2 = Pl_Continue;

   753 	if (pPlayer->IsInGame())

   754 	{

   755 		m_clcommand->PushCell(client);

   756 		m_clcommand->PushCell(argcount);

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

   758 	}

   760 	if (res2 > res)

   761 	{

   762 		res = res2;

   763 	}

   765 	if (res >= Pl_Stop)

   766 	{

   767 		g_HL2.PopCommandStack();

   768 		RETURN_META(MRES_SUPERCEDE);

   769 	}

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

   773 	g_HL2.PopCommandStack();

   775 	if (res >= Pl_Handled)

   776 	{

   777 		RETURN_META(MRES_SUPERCEDE);

   778 	}

   779 }

   781 void PlayerManager::OnClientSettingsChanged(edict_t *pEntity)

   782 {

   783 	cell_t res;

   784 	int client = IndexOfEdict(pEntity);

   785 	CPlayer *pPlayer = &m_Players[client];

   787 	if (!pPlayer->IsConnected())

   788 	{

   789 		return;

   790 	}

   792 	m_clinfochanged->PushCell(client);

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

   795 	if (pPlayer->IsFakeClient())

   796 	{

   797 		return;

   798 	}

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

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

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

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

   805 	{

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

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

   808 		{

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

   810 			{

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

   812 				RETURN_META(MRES_IGNORED);

   813 			}

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

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

   816 			{

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

   818 				pPlayer->SetAdminId(INVALID_ADMIN_ID, false);

   819 			}

   820 		}

   821 		pPlayer->SetName(new_name);

   822 	}

   824 	if (m_PassInfoVar.size() > 0)

   825 	{

   826 		/* Try for a password change */

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

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

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

   830 		{

   831 			pPlayer->m_LastPassword.assign(new_pass);

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

   833 			{

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

   835 				pPlayer->DoBasicAdminChecks();

   836 			}

   837 		}

   838 	}

   839 	/* Notify Extensions */

   840 	List<IClientListener *>::iterator iter;

   841 	IClientListener *pListener = NULL;

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

   843 	{

   844 		pListener = (*iter);

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

   846 		{

   847 			pListener->OnClientSettingsChanged(client);

   848 		}

   849 	}

   850 }

   852 int PlayerManager::GetMaxClients()

   853 {

   854 	return gpGlobals->maxClients;

   855 }

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

   858 {

   859 	if (client > gpGlobals->maxClients || client < 1)

   860 	{

   861 		return NULL;

   862 	}

   863 	return &m_Players[client];

   864 }

   866 int PlayerManager::GetNumPlayers()

   867 {

   868 	return m_PlayerCount;

   869 }

   871 int PlayerManager::GetClientOfUserId(int userid)

   872 {

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

   874 	{

   875 		return 0;

   876 	}

   878 	int client = m_UserIdLookUp[userid];

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

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

   882 	 * check before invoking this backwards compat code.

   883 	 */

   884 	if (client)

   885 	{

   886 		CPlayer *player = GetPlayerByIndex(client);

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

   888 		{

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

   890 			if (realUserId == userid)

   891 			{

   892 				return client;

   893 			}

   894 		}

   895 	}

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

   898 	CPlayer *player;

   899 	int maxClients = gpGlobals->maxClients;

   900 	for (int i = 1; i <= maxClients; i++)

   901 	{

   902 		player = GetPlayerByIndex(i);

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

   904 		{

   905 			continue;

   906 		}

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

   908 		{

   909 			m_UserIdLookUp[userid] = i;

   910 			return i;

   911 		}

   912 	}

   914 	return 0;

   915 }

   917 void PlayerManager::AddClientListener(IClientListener *listener)

   918 {

   919 	m_hooks.push_back(listener);

   920 }

   922 void PlayerManager::RemoveClientListener(IClientListener *listener)

   923 {

   924 	m_hooks.remove(listener);

   925 }

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

   928 {

   929 	int index = IndexOfEdict(pEdict);

   930 	return GetGamePlayer(index);

   931 }

   933 IGamePlayer *PlayerManager::GetGamePlayer(int client)

   934 {

   935 	return GetPlayerByIndex(client);

   936 }

   938 void PlayerManager::ClearAdminId(AdminId id)

   939 {

   940 	int maxClients = gpGlobals->maxClients;

   941 	for (int i=1; i<=maxClients; i++)

   942 	{

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

   944 		{

   945 			m_Players[i].DumpAdmin(true);

   946 		}

   947 	}

   948 }

   950 void PlayerManager::ClearAllAdmins()

   951 {

   952 	// Players may not be inited if server hadn't been activated

   953 	if (!m_Players)

   954 	{

   955 		return;

   956 	}

   958 	int maxClients = gpGlobals->maxClients;

   959 	for (int i=1; i<=maxClients; i++)

   960 	{

   961 		m_Players[i].DumpAdmin(true);

   962 	}

   963 }

   965 const char *PlayerManager::GetPassInfoVar()

   966 {

   967 	return m_PassInfoVar.c_str();

   968 }

   970 void PlayerManager::RecheckAnyAdmins()

   971 {

   972 	// Players may not be inited if server hadn't been activated

   973 	if (!m_Players)

   974 	{

   975 		return;

   976 	}

   978 	int maxClients = gpGlobals->maxClients;

   979 	for (int i=1; i<=maxClients; i++)

   980 	{

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

   982 		{

   983 			m_Players[i].DoBasicAdminChecks();

   984 		}

   985 	}

   986 }

   988 unsigned int PlayerManager::GetReplyTo()

   989 {

   990 	return g_ChatTriggers.GetReplyTo();

   991 }

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

   994 {

   995 	return g_ChatTriggers.SetReplyTo(reply);

   996 }

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

   999 {

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

  1001 }

  1003 void PlayerManager::RegisterCommandTargetProcessor(ICommandTargetProcessor *pHandler)

  1004 {

  1005 	target_processors.push_back(pHandler);

  1006 }

  1008 void PlayerManager::UnregisterCommandTargetProcessor(ICommandTargetProcessor *pHandler)

  1009 {

  1010 	target_processors.remove(pHandler);

  1011 }

  1013 void PlayerManager::InvalidatePlayer(CPlayer *pPlayer)

  1014 {

  1015 	/**

  1016 	* Remove client from auth queue if necessary

  1017 	*/

  1018 	if (!pPlayer->IsAuthorized())

  1019 	{

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

  1021 		{

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

  1023 			{

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

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

  1026 				{

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

  1028 				}

  1029 				/* Remove us and break */

  1030 				m_AuthQueue[0]--;

  1031 				break;

  1032 			}

  1033 		}

  1034 	}

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

  1037 	pPlayer->Disconnect();

  1038 }

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

  1041 {

  1042 	if ((flags & COMMAND_FILTER_CONNECTED) == COMMAND_FILTER_CONNECTED

  1043 		&& !pTarget->IsConnected())

  1044 	{

  1045 		return COMMAND_TARGET_NONE;

  1046 	}

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

  1048 		!pTarget->IsInGame())

  1049 	{

  1050 		return COMMAND_TARGET_NOT_IN_GAME;

  1051 	}

  1053 	if ((flags & COMMAND_FILTER_NO_BOTS) == COMMAND_FILTER_NO_BOTS

  1054 		&& pTarget->IsFakeClient())

  1055 	{

  1056 		return COMMAND_TARGET_NOT_HUMAN;

  1057 	}

  1059 	if (pAdmin != NULL)

  1060 	{

  1061 		if ((flags & COMMAND_FILTER_NO_IMMUNITY) != COMMAND_FILTER_NO_IMMUNITY

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

  1063 		{

  1064 			return COMMAND_TARGET_IMMUNE;

  1065 		}

  1066 	}

  1068 	if ((flags & COMMAND_FILTER_ALIVE) == COMMAND_FILTER_ALIVE

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

  1070 	{

  1071 		return COMMAND_TARGET_NOT_ALIVE;

  1072 	}

  1074 	if ((flags & COMMAND_FILTER_DEAD) == COMMAND_FILTER_DEAD

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

  1076 	{

  1077 		return COMMAND_TARGET_NOT_DEAD;

  1078 	}

  1080 	return COMMAND_TARGET_VALID;

  1081 }

  1083 void PlayerManager::ProcessCommandTarget(cmd_target_info_t *info)

  1084 {

  1085 	CPlayer *pTarget, *pAdmin;

  1086 	int max_clients, total = 0;

  1088 	max_clients = GetMaxClients();

  1090 	if (info->max_targets < 1)

  1091 	{

  1092 		info->reason = COMMAND_TARGET_NONE;

  1093 		info->num_targets = 0;

  1094 	}

  1096 	if (info->admin == 0)

  1097 	{

  1098 		pAdmin = NULL;

  1099 	}

  1100 	else

  1101 	{

  1102 		pAdmin = GetPlayerByIndex(info->admin);

  1103 	}

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

  1106 	{

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

  1108 		int client = GetClientOfUserId(userid);

  1110 		/* See if a valid userid matched */

  1111 		if (client > 0)

  1112 		{

  1113 			IGamePlayer *pTarget = GetPlayerByIndex(client);

  1114 			if (pTarget != NULL)

  1115 			{

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

  1117 				{

  1118 					info->targets[0] = client;

  1119 					info->num_targets = 1;

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

  1121 					info->target_name_style = COMMAND_TARGETNAME_RAW;

  1122 				}

  1123 				else

  1124 				{

  1125 					info->num_targets = 0;

  1126 				}

  1127 				return;

  1128 			}

  1129 		}

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

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

  1133 		{

  1134 			size_t p, len;

  1135 			char new_pattern[256];

  1137 			strcpy(new_pattern, "STEAM_");

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

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

  1140 			{

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

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

  1143 				{

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

  1145 				}

  1146 			}

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

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

  1150 			{

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

  1152 				{

  1153 					continue;

  1154 				}

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

  1156 				{

  1157 					continue;

  1158 				}

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

  1160 				{

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

  1162 						== COMMAND_TARGET_VALID)

  1163 					{

  1164 						info->targets[0] = i;

  1165 						info->num_targets = 1;

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

  1167 						info->target_name_style = COMMAND_TARGETNAME_RAW;

  1168 					}

  1169 					else

  1170 					{

  1171 						info->num_targets = 0;

  1172 					}

  1173 					return;

  1174 				}

  1175 			}

  1176 		}

  1178 		/* See if an exact name matches */

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

  1180 		{

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

  1182 			{

  1183 				continue;

  1184 			}

  1185 			if  (!pTarget->IsConnected())

  1186 			{

  1187 				continue;

  1188 			}

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

  1190 			{

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

  1192 					== COMMAND_TARGET_VALID)

  1193 				{

  1194 					info->targets[0] = i;

  1195 					info->num_targets = 1;

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

  1197 					info->target_name_style = COMMAND_TARGETNAME_RAW;

  1198 				}

  1199 				else

  1200 				{

  1201 					info->num_targets = 0;

  1202 				}

  1203 				return;

  1204 			}

  1205 		}

  1206 	}

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

  1209 	{

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

  1211 		if (info->reason == COMMAND_TARGET_VALID)

  1212 		{

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

  1214 			info->num_targets = 1;

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

  1216 			info->target_name_style = COMMAND_TARGETNAME_RAW;

  1217 		}

  1218 		else

  1219 		{

  1220 			info->num_targets = 0;

  1221 		}

  1222 		return;

  1223 	}

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

  1226 	{

  1227 		bool is_multi = false;

  1228 		bool bots_only = false;

  1229 		int skip_client = -1;

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

  1232 		{

  1233 			is_multi = true;

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

  1235 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1236 		}

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

  1238 		{

  1239 			is_multi = true;

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

  1241 			{

  1242 				info->num_targets = 0;

  1243 				info->reason = COMMAND_TARGET_NOT_ALIVE;

  1244 				return;

  1245 			}

  1246 			info->flags |= COMMAND_FILTER_DEAD;

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

  1248 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1249 		}

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

  1251 		{

  1252 			is_multi = true;

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

  1254 			{

  1255 				info->num_targets = 0;

  1256 				info->reason = COMMAND_TARGET_NOT_DEAD;

  1257 				return;

  1258 			}

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

  1260 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1261 			info->flags |= COMMAND_FILTER_ALIVE;

  1262 		}

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

  1264 		{

  1265 			is_multi = true;

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

  1267 			{

  1268 				info->num_targets = 0;

  1269 				info->reason = COMMAND_FILTER_NO_BOTS;

  1270 				return;

  1271 			}

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

  1273 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1274 			bots_only = true;

  1275 		}

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

  1277 		{

  1278 			is_multi = true;

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

  1280 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1281 			info->flags |= COMMAND_FILTER_NO_BOTS;

  1282 		}

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

  1284 		{

  1285 			is_multi = true;

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

  1287 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1288 			skip_client = info->admin;

  1289 		}

  1291 		if (is_multi)

  1292 		{

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

  1294 			{

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

  1296 				{

  1297 					continue;

  1298 				}

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

  1300 				{

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

  1302 						&& skip_client != i)

  1303 					{

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

  1305 					}

  1306 				}

  1307 			}

  1309 			info->num_targets = total;

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

  1311 			return;

  1312 		}

  1313 	}

  1315 	List<ICommandTargetProcessor *>::iterator iter;

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

  1317 	{

  1318 		ICommandTargetProcessor *pProcessor = (*iter);

  1319 		if (pProcessor->ProcessCommandTarget(info))

  1320 		{

  1321 			return;

  1322 		}

  1323 	}

  1325 	/* Check partial names */

  1326 	int found_client = 0;

  1327 	CPlayer *pFoundClient = NULL;

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

  1329 	{

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

  1331 		{

  1332 			continue;

  1333 		}

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

  1336 		{

  1337 			if (found_client)

  1338 			{

  1339 				info->num_targets = 0;

  1340 				info->reason = COMMAND_TARGET_AMBIGUOUS;

  1341 				return;

  1342 			}

  1343 			else

  1344 			{

  1345 				found_client = i;

  1346 				pFoundClient = pTarget;

  1347 			}

  1348 		}

  1349 	}

  1351 	if (found_client)

  1352 	{

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

  1354 			== COMMAND_TARGET_VALID)

  1355 		{

  1356 			info->targets[0] = found_client;

  1357 			info->num_targets = 1;

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

  1359 			info->target_name_style = COMMAND_TARGETNAME_RAW;

  1360 		}

  1361 		else

  1362 		{

  1363 			info->num_targets = 0;

  1364 		}

  1365 	}

  1366 	else

  1367 	{

  1368 		info->num_targets = 0;

  1369 		info->reason = COMMAND_TARGET_NONE;

  1370 	}

  1371 }

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

  1374 {

  1375 	if (!m_FirstPass)

  1376 	{

  1377 		return;

  1378 	}

  1380 	if (newvalue == -1)

  1381 	{

  1382 		newvalue = gpGlobals->maxClients;

  1383 	}

  1385 	if (newvalue == MaxClients())

  1386 	{

  1387 		return;

  1388 	}

  1390 	/* Notify the rest of core */

  1391 	SMGlobalClass *pBase = SMGlobalClass::head;

  1392 	while (pBase)

  1393 	{

  1394 		pBase->OnSourceModMaxPlayersChanged(newvalue);

  1395 		pBase = pBase->m_pGlobalClassNext;

  1396 	}

  1398 	/* Notify Extensions */

  1399 	List<IClientListener *>::iterator iter;

  1400 	IClientListener *pListener = NULL;

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

  1402 	{

  1403 		pListener = (*iter);

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

  1405 		{

  1406 			pListener->OnMaxPlayersChanged(newvalue);

  1407 		}

  1408 	}

  1409 }

  1411 int PlayerManager::GetClientFromSerial(unsigned int serial)

  1412 {

  1413 	serial_t s;

  1414 	s.value = serial;

  1416 	int client = s.bits.index;

  1418 	IGamePlayer *pPlayer = GetGamePlayer(client);

  1420 	if (!pPlayer)

  1421 	{

  1422 		return 0;

  1423 	}

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

  1426 	{

  1427 		return client;

  1428 	}

  1430 	return 0;

  1431 }

  1433 #if SOURCE_ENGINE >= SE_ORANGEBOX

  1434 void CmdMaxplayersCallback(const CCommand &command)

  1435 {

  1436 #else

  1437 void CmdMaxplayersCallback()

  1438 {

  1439 #endif

  1441 	g_Players.MaxPlayersChanged();

  1442 }

  1445 /*******************

  1446  *** PLAYER CODE ***

  1447  *******************/

  1449 CPlayer::CPlayer()

  1450 {

  1451 	m_IsConnected = false;

  1452 	m_IsInGame = false;

  1453 	m_IsAuthorized = false;

  1454 	m_pEdict = NULL;

  1455 	m_Admin = INVALID_ADMIN_ID;

  1456 	m_TempAdmin = false;

  1457 	m_Info = NULL;

  1458 	m_bAdminCheckSignalled = false;

  1459 	m_UserId = -1;

  1460 	m_bIsInKickQueue = false;

  1461 	m_LastPassword.clear();

  1462 	m_LangId = SOURCEMOD_LANGUAGE_ENGLISH;

  1463 	m_bFakeClient = false;

  1464 }

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

  1467 {

  1468 	m_IsConnected = true;

  1469 	m_Name.assign(name);

  1470 	m_Ip.assign(ip);

  1471 	m_pEdict = pEntity;

  1472 	m_iIndex = IndexOfEdict(pEntity);

  1473 	m_LangId = translator->GetServerLanguage();

  1475 	m_Serial.bits.index = m_iIndex;

  1476 	m_Serial.bits.serial = g_PlayerSerialCount++;

  1478 	char ip2[24], *ptr;

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

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

  1481 	{

  1482 		*ptr = '\0';

  1483 	}

  1484 	m_IpNoPort.assign(ip2);

  1485 }

  1487 void CPlayer::Connect()

  1488 {

  1489 	if (m_IsInGame)

  1490 	{

  1491 		return;

  1492 	}

  1494 	m_IsInGame = true;

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

  1497 	int client = IndexOfEdict(m_pEdict);

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

  1499 	{

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

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

  1502 	}

  1503 	else

  1504 	{

  1505 		m_LastPassword.assign("");

  1506 	}

  1507 }

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

  1510 {

  1511 	if (m_IsAuthorized)

  1512 	{

  1513 		return;

  1514 	}

  1516 	m_IsAuthorized = true;

  1517 	m_AuthID.assign(steamid);

  1518 }

  1520 void CPlayer::Disconnect()

  1521 {

  1522 	DumpAdmin(false);

  1523 	m_IsConnected = false;

  1524 	m_IsInGame = false;

  1525 	m_IsAuthorized = false;

  1526 	m_Name.clear();

  1527 	m_Ip.clear();

  1528 	m_AuthID.clear();

  1529 	m_pEdict = NULL;

  1530 	m_Info = NULL;

  1531 	m_bAdminCheckSignalled = false;

  1532 	m_UserId = -1;

  1533 	m_bIsInKickQueue = false;

  1534 	m_bFakeClient = false;

  1535 }

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

  1538 {

  1539 	m_Name.assign(name);

  1540 }

  1542 const char *CPlayer::GetName()

  1543 {

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

  1545 	{

  1546 		return m_Info->GetName();

  1547 	}

  1549 	return m_Name.c_str();

  1550 }

  1552 const char *CPlayer::GetIPAddress()

  1553 {

  1554 	return m_Ip.c_str();

  1555 }

  1557 const char *CPlayer::GetAuthString()

  1558 {

  1559 	return m_AuthID.c_str();

  1560 }

  1562 edict_t *CPlayer::GetEdict()

  1563 {

  1564 	return m_pEdict;

  1565 }

  1567 bool CPlayer::IsInGame()

  1568 {

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

  1570 }

  1572 bool CPlayer::WasCountedAsInGame()

  1573 {

  1574 	return m_IsInGame;

  1575 }

  1577 bool CPlayer::IsConnected()

  1578 {

  1579 	return m_IsConnected;

  1580 }

  1582 bool CPlayer::IsAuthorized()

  1583 {

  1584 	return m_IsAuthorized;

  1585 }

  1587 IPlayerInfo *CPlayer::GetPlayerInfo()

  1588 {

  1589 	if (m_pEdict->GetUnknown())

  1590 	{

  1591 		return m_Info;

  1592 	}

  1594 	return NULL;

  1595 }

  1597 bool CPlayer::IsFakeClient()

  1598 {

  1599 	return m_bFakeClient;

  1600 }

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

  1603 {

  1604 	if (!m_IsConnected)

  1605 	{

  1606 		return;

  1607 	}

  1609 	DumpAdmin(false);

  1611 	m_Admin = id;

  1612 	m_TempAdmin = temporary;

  1613 }

  1615 AdminId CPlayer::GetAdminId()

  1616 {

  1617 	return m_Admin;

  1618 }

  1620 void CPlayer::DumpAdmin(bool deleting)

  1621 {

  1622 	if (m_Admin != INVALID_ADMIN_ID)

  1623 	{

  1624 		if (m_TempAdmin && !deleting)

  1625 		{

  1626 			g_Admins.InvalidateAdmin(m_Admin);

  1627 		}

  1628 		m_Admin = INVALID_ADMIN_ID;

  1629 		m_TempAdmin = false;

  1630 	}

  1631 }

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

  1634 {

  1635 	MarkAsBeingKicked();

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

  1637 	if (pNetChan == NULL)

  1638 	{

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

  1640 		int userid = GetUserId();

  1641 		if (userid > 0)

  1642 		{

  1643 			char buffer[255];

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

  1645 			engine->ServerCommand(buffer);

  1646 		}

  1647 	}

  1648 	else

  1649 	{

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

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

  1652 	}

  1653 }

  1655 void CPlayer::Authorize_Post()

  1656 {

  1657 	if (m_IsInGame)

  1658 	{

  1659 		DoPostConnectAuthorization();

  1660 	}

  1661 }

  1663 void CPlayer::DoPostConnectAuthorization()

  1664 {

  1665 	bool delay = false;

  1667 	List<IClientListener *>::iterator iter;

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

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

  1670 		 iter++)

  1671 	{

  1672 		IClientListener *pListener = (*iter);

  1673 #if defined MIN_API_FOR_ADMINCALLS

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

  1675 		{

  1676 			continue;

  1677 		}

  1678 #endif

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

  1680 		{

  1681 			delay = true;

  1682 		}

  1683 	}

  1685 	cell_t result = 0;

  1686 	PreAdminCheck->PushCell(m_iIndex);

  1687 	PreAdminCheck->Execute(&result);

  1689 	/* Defer, for better or worse */

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

  1691 	{

  1692 		return;

  1693 	}

  1695 	/* Sanity check */

  1696 	if (!IsConnected())

  1697 	{

  1698 		return;

  1699 	}

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

  1702 	DoBasicAdminChecks();

  1704 	/* Send the notification out */

  1705 	NotifyPostAdminChecks();

  1706 }

  1708 bool CPlayer::RunAdminCacheChecks()

  1709 {

  1710 	AdminId old_id = GetAdminId();

  1712 	DoBasicAdminChecks();

  1714 	return (GetAdminId() != old_id);

  1715 }

  1717 void CPlayer::NotifyPostAdminChecks()

  1718 {

  1719 	if (m_bAdminCheckSignalled)

  1720 	{

  1721 		return;

  1722 	}

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

  1725 	m_bAdminCheckSignalled = true;

  1727 	List<IClientListener *>::iterator iter;

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

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

  1730 		iter++)

  1731 	{

  1732 		IClientListener *pListener = (*iter);

  1733 #if defined MIN_API_FOR_ADMINCALLS

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

  1735 		{

  1736 			continue;

  1737 		}

  1738 #endif

  1739 		pListener->OnClientPostAdminCheck(m_iIndex);

  1740 	}

  1742 	PostAdminFilter->PushCell(m_iIndex);

  1743 	PostAdminFilter->Execute(NULL);

  1745 	PostAdminCheck->PushCell(m_iIndex);

  1746 	PostAdminCheck->Execute(NULL);

  1747 }

  1749 void CPlayer::DoBasicAdminChecks()

  1750 {

  1751 	if (GetAdminId() != INVALID_ADMIN_ID)

  1752 	{

  1753 		return;

  1754 	}

  1756 	/* First check the name */

  1757 	AdminId id;

  1758 	int client = IndexOfEdict(m_pEdict);

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

  1761 	{

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

  1763 		{

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

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

  1766 		}

  1767 		return;

  1768 	}

  1770 	/* Check IP */

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

  1772 	{

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

  1774 		{

  1775 			return;

  1776 		}

  1777 	}

  1779 	/* Check steam id */

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

  1781 	{

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

  1783 		{

  1784 			return;

  1785 		}

  1786 	}

  1787 }

  1789 unsigned int CPlayer::GetLanguageId()

  1790 {

  1791 	return m_LangId;

  1792 }

  1794 void CPlayer::SetLanguageId(unsigned int id)

  1795 {

  1796 	m_LangId = id;

  1797 }

  1799 int CPlayer::GetUserId()

  1800 {

  1801 	if (m_UserId == -1)

  1802 	{

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

  1804 	}

  1806 	return m_UserId;

  1807 }

  1809 bool CPlayer::IsInKickQueue()

  1810 {

  1811 	return m_bIsInKickQueue;

  1812 }

  1814 void CPlayer::MarkAsBeingKicked()

  1815 {

  1816 	m_bIsInKickQueue = true;

  1817 }

  1819 int CPlayer::GetLifeState()

  1820 {

  1821 	if (lifestate_offset == -1)

  1822 	{

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

  1824 		{

  1825 			lifestate_offset = -2;

  1826 		}

  1827 	}

  1829 	if (lifestate_offset < 0)

  1830 	{

  1831 		IPlayerInfo *info = GetPlayerInfo();

  1832 		if (info == NULL)

  1833 		{

  1834 			return PLAYER_LIFE_UNKNOWN;

  1835 		}

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

  1837 	}

  1839 	if (m_pEdict == NULL)

  1840 	{

  1841 		return PLAYER_LIFE_UNKNOWN;

  1842 	}

  1844 	CBaseEntity *pEntity;

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

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

  1847 	{

  1848 		return PLAYER_LIFE_UNKNOWN;

  1849 	}

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

  1852 	{

  1853 		return PLAYER_LIFE_ALIVE;

  1854 	}

  1855 	else

  1856 	{

  1857 		return PLAYER_LIFE_DEAD;

  1858 	}

  1859 }

  1861 unsigned int CPlayer::GetSerial()

  1862 {

  1863 	return m_Serial.value;

  1864 }

author	Nicholas Hastings <skamonkey@gmail.com>
	Fri Jul 08 07:53:14 2011 -0400 (2011-07-08)
changeset 3347	72a4e13eb106
parent 3346	344daca49587
child 3349	65bc60635110
permissions	-rw-r--r--