sourcemod-central: core/PlayerManager.cpp@2c7137f077fe

     1 /**

     2  * vim: set ts=4 :

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

     4  * SourceMod

     5  * Copyright (C) 2004-2008 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 "Translator.h"

    43 #include "Logger.h"

    44 #include "ChatTriggers.h"

    45 #include "HalfLife2.h"

    46 #include <inetchannel.h>

    47 #include <iclient.h>

    48 #include "GameConfigs.h"

    49 #include "ExtensionSys.h"

    50 #include <sourcemod_version.h>

    51 #include "ConsoleDetours.h"

    53 PlayerManager g_Players;

    54 bool g_OnMapStarted = false;

    55 IForward *PreAdminCheck = NULL;

    56 IForward *PostAdminCheck = NULL;

    57 IForward *PostAdminFilter = NULL;

    58 IForward *OnClientConnected = 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 extern bool __SourceHook_FHAddConCommandDispatch(void *,bool,class fastdelegate::FastDelegate0<void>);

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

    81 #endif

    83 ConCommand *maxplayersCmd = NULL;

    85 unsigned int g_PlayerSerialCount = 0;

    87 class KickPlayerTimer : public ITimedEvent

    88 {

    89 public:

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

    91 	{

    92 		int userid = (int)pData;

    93 		int client = g_Players.GetClientOfUserId(userid);

    94 		if (client)

    95 		{

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

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

    98 		}

    99 		return Pl_Stop;

   100 	}

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

   102 	{

   103 	}

   104 } s_KickPlayerTimer;

   106 PlayerManager::PlayerManager()

   107 {

   108 	m_AuthQueue = NULL;

   109 	m_FirstPass = false;

   110 	m_maxClients = 0;

   112 	m_UserIdLookUp = new int[USHRT_MAX+1];

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

   114 }

   116 PlayerManager::~PlayerManager()

   117 {

   118 	g_NumPlayersToAuth = NULL;

   120 	delete [] m_AuthQueue;

   121 	delete [] m_UserIdLookUp;

   122 }

   124 void PlayerManager::OnSourceModAllInitialized()

   125 {

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

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

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

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

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

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

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

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

   135 	g_ShareSys.AddInterface(NULL, this);

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

   138 	ParamType p2[] = {Param_Cell};

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

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

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

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

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

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

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

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

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

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

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

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

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

   155 	m_bIsListenServer = !engine->IsDedicatedServer();

   156 	m_ListenClient = 0;

   158 	g_ConVarManager.AddConVarChangeListener("tv_enable", this);

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

   161 	if (pCmd != NULL)

   162 	{

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

   164 		maxplayersCmd = pCmd;

   165 	}

   166 }

   168 void PlayerManager::OnSourceModShutdown()

   169 {

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

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

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

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

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

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

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

   178 	/* Release forwards */

   179 	g_Forwards.ReleaseForward(m_clconnect);

   180 	g_Forwards.ReleaseForward(m_clputinserver);

   181 	g_Forwards.ReleaseForward(m_cldisconnect);

   182 	g_Forwards.ReleaseForward(m_cldisconnect_post);

   183 	g_Forwards.ReleaseForward(m_clcommand);

   184 	g_Forwards.ReleaseForward(m_clinfochanged);

   185 	g_Forwards.ReleaseForward(m_clauth);

   186 	g_Forwards.ReleaseForward(m_onActivate);

   187 	g_Forwards.ReleaseForward(m_onActivate2);

   188 	g_Forwards.ReleaseForward(OnClientConnected);

   190 	g_Forwards.ReleaseForward(PreAdminCheck);

   191 	g_Forwards.ReleaseForward(PostAdminCheck);

   192 	g_Forwards.ReleaseForward(PostAdminFilter);

   194 	delete [] m_Players;

   196 	g_ConVarManager.RemoveConVarChangeListener("tv_enable", this);

   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 	if (!m_FirstPass)

   235 	{

   236 		/* Initialize all players */

   237 		m_maxClients = clientMax;

   238 		m_PlayerCount = 0;

   239 		m_Players = new CPlayer[ABSOLUTE_PLAYER_LIMIT + 1];

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

   241 		m_FirstPass = true;

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

   245 		g_NumPlayersToAuth = &m_AuthQueue[0];

   247 		g_PluginSys.SyncMaxClients(clientMax);

   248 	}

   249 	g_Extensions.CallOnCoreMapStart(pEdictList, edictCount, clientMax);

   250 	m_onActivate->Execute(NULL);

   251 	m_onActivate2->Execute(NULL);

   253 	List<IClientListener *>::iterator iter;

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

   255 	{

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

   257 		{

   258 			(*iter)->OnServerActivated(clientMax);

   259 		}

   260 	}

   262 	g_OnMapStarted = true;

   264 	SMGlobalClass *cls = SMGlobalClass::head;

   265 	while (cls)

   266 	{

   267 		cls->OnSourceModLevelActivated();

   268 		cls = cls->m_pGlobalClassNext;

   269 	}

   271 	SM_ExecuteAllConfigs();

   272 }

   274 bool PlayerManager::IsServerActivated()

   275 {

   276 	return m_FirstPass;

   277 }

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

   280 {

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

   282 	if (password != NULL)

   283 	{

   284 		if (m_PassInfoVar.size() < 1)

   285 		{

   286 			return false;

   287 		}

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

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

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

   292 		{

   293 			return false;

   294 		}

   295 	}

   297 	pPlayer->SetAdminId(id, false);

   299 	return true;

   300 }

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

   303 {

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

   305 	if (password == NULL)

   306 	{

   307 		return false;

   308 	}

   310 	if (m_PassInfoVar.size() < 1)

   311 	{

   312 		return false;

   313 	}

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

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

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

   318 	{

   319 		return false;

   320 	}

   322 	pPlayer->SetAdminId(id, false);

   324 	return true;

   325 }

   327 void PlayerManager::RunAuthChecks()

   328 {

   329 	CPlayer *pPlayer;

   330 	const char *authstr;

   331 	unsigned int removed = 0;

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

   333 	{

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

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

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

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

   338 		{

   339 			/* Set authorization */

   340 			pPlayer->Authorize(authstr);

   342 			/* Mark as removed from queue */

   343 			unsigned int client = m_AuthQueue[i];

   344 			m_AuthQueue[i] = 0;

   345 			removed++;

   347 			/* Send to extensions */

   348 			List<IClientListener *>::iterator iter;

   349 			IClientListener *pListener;

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

   351 			{

   352 				pListener = (*iter);

   353 				pListener->OnClientAuthorized(client, authstr);

   354 				if (!pPlayer->IsConnected())

   355 				{

   356 					break;

   357 				}

   358 			}

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

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

   362 			{

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

   364 				m_clauth->PushCell(client);

   365 				m_clauth->PushString(authstr);

   366 				m_clauth->Execute(NULL);

   367 			}

   369 			if (pPlayer->IsConnected())

   370 			{

   371 				pPlayer->Authorize_Post();

   372 			}

   373 		}

   374 	}

   376 	/* Clean up the queue */

   377 	if (removed)

   378 	{

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

   380 		if (removed != m_AuthQueue[0])

   381 		{

   382 			unsigned int diff = 0;

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

   384 			{

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

   386 				if (m_AuthQueue[i] == 0)

   387 				{

   388 					/* Increase the differential */

   389 					diff++;

   390 				} else {

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

   392 					assert(i > diff);

   393 					assert(i - diff >= 1);

   394 					/* move this index down */

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

   396 				}

   397 			}

   398 			m_AuthQueue[0] -= removed;

   399 		} else {

   400 			m_AuthQueue[0] = 0;

   401 		}

   402 	}

   403 }

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

   406 {

   407 	int client = IndexOfEdict(pEntity);

   408 	CPlayer *pPlayer = &m_Players[client];

   410 	List<IClientListener *>::iterator iter;

   411 	IClientListener *pListener = NULL;

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

   413 	{

   414 		pListener = (*iter);

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

   416 		{

   417 			return false;

   418 		}

   419 	}

   421 	cell_t res = 1;

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

   424 	m_clconnect->PushCell(client);

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

   426 	m_clconnect->PushCell(maxrejectlen);

   427 	m_clconnect->Execute(&res);

   429 	if (res)

   430 	{

   431 		if (!pPlayer->IsAuthorized())

   432 		{

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

   434 		}

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

   437 	}

   438 	else

   439 	{

   440 		if (!pPlayer->IsFakeClient())

   441 		{

   442 			RETURN_META_VALUE(MRES_SUPERCEDE, false);

   443 		}

   444 	}

   446 	return true;

   447 }

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

   450 {

   451 	int client = IndexOfEdict(pEntity);

   452 	bool orig_value = META_RESULT_ORIG_RET(bool);

   453 	CPlayer *pPlayer = &m_Players[client];

   455 	if (orig_value)

   456 	{

   457 		List<IClientListener *>::iterator iter;

   458 		IClientListener *pListener = NULL;

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

   460 		{

   461 			pListener = (*iter);

   462 			pListener->OnClientConnected(client);

   463 			if (!pPlayer->IsConnected())

   464 			{

   465 				break;

   466 			}

   467 		}

   469 		if (!pPlayer->IsFakeClient()

   470 			&& m_bIsListenServer

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

   472 		{

   473 			m_ListenClient = client;

   474 		}

   476 		cell_t res;

   477 		OnClientConnected->PushCell(client);

   478 		OnClientConnected->Execute(&res, NULL);

   479 	}

   480 	else

   481 	{

   482 		InvalidatePlayer(pPlayer);

   483 	}

   485 	return true;

   486 }

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

   489 {

   490 	cell_t res;

   491 	int client = IndexOfEdict(pEntity);

   492 	CPlayer *pPlayer = &m_Players[client];

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

   495 	if (!pPlayer->IsConnected())

   496 	{

   497 		/* Run manual connection routines */

   498 		char error[255];

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

   500 		pPlayer->Authorize(authid);

   501 		pPlayer->m_bFakeClient = true;

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

   503 		{

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

   505 			return;

   506 		}

   507 		List<IClientListener *>::iterator iter;

   508 		IClientListener *pListener = NULL;

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

   510 		{

   511 			pListener = (*iter);

   512 			pListener->OnClientConnected(client);

   513 			/* See if bot was kicked */

   514 			if (!pPlayer->IsConnected())

   515 			{

   516 				return;

   517 			}

   518 		}

   519 		/* Now do authorization */

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

   521 		{

   522 			pListener = (*iter);

   523 			pListener->OnClientAuthorized(client, authid);

   524 		}

   525 		/* Finally, tell plugins */

   526 		if (m_clauth->GetFunctionCount())

   527 		{

   528 			m_clauth->PushCell(client);

   529 			m_clauth->PushString(authid);

   530 			m_clauth->Execute(NULL);

   531 		}

   532 		pPlayer->Authorize_Post();

   533 	}

   535 	if (playerinfo)

   536 	{

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

   538 	}

   540 	/* Get the client's language */

   541 	if (m_QueryLang)

   542 	{

   543 		const char *name;

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

   545 		{

   546 			unsigned int langid;

   547 			pPlayer->m_LangId = (g_Translator.GetLanguageByName(name, &langid)) ? langid : g_Translator.GetServerLanguage();

   548 		} else {

   549 			pPlayer->m_LangId = g_Translator.GetServerLanguage();

   550 		}

   551 	}

   553 	pPlayer->Connect();

   554 	m_PlayerCount++;

   556 	List<IClientListener *>::iterator iter;

   557 	IClientListener *pListener = NULL;

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

   559 	{

   560 		pListener = (*iter);

   561 		pListener->OnClientPutInServer(client);

   562 	}

   564 	m_clputinserver->PushCell(client);

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

   567 	if (pPlayer->IsAuthorized())

   568 	{

   569 		pPlayer->DoPostConnectAuthorization();

   570 	}

   571 }

   573 void PlayerManager::OnSourceModLevelEnd()

   574 {

   575 	/* Disconnect all bots still in game */

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

   577 	{

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

   579 		{

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

   581 		}

   582 	}

   583 	m_PlayerCount = 0;

   584 }

   586 void PlayerManager::OnClientDisconnect(edict_t *pEntity)

   587 {

   588 	cell_t res;

   589 	int client = IndexOfEdict(pEntity);

   590 	CPlayer *pPlayer = &m_Players[client];

   592 	if (pPlayer->IsConnected())

   593 	{

   594 		m_cldisconnect->PushCell(client);

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

   596 	}

   597 	else

   598 	{

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

   600 		return;

   601 	}

   603 	if (pPlayer->WasCountedAsInGame())

   604 	{

   605 		m_PlayerCount--;

   606 	}

   608 	List<IClientListener *>::iterator iter;

   609 	IClientListener *pListener = NULL;

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

   611 	{

   612 		pListener = (*iter);

   613 		pListener->OnClientDisconnecting(client);

   614 	}

   616 	InvalidatePlayer(pPlayer);

   618 	if (m_ListenClient == client)

   619 	{

   620 		m_ListenClient = 0;

   621 	}

   622 }

   624 void PlayerManager::OnClientDisconnect_Post(edict_t *pEntity)

   625 {

   626 	cell_t res;

   627 	int client = IndexOfEdict(pEntity);

   629 	m_cldisconnect_post->PushCell(client);

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

   632 	List<IClientListener *>::iterator iter;

   633 	IClientListener *pListener = NULL;

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

   635 	{

   636 		pListener = (*iter);

   637 		pListener->OnClientDisconnected(client);

   638 	}

   639 }

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

   642 {

   643 	char buffer[512];

   645 	va_list ap;

   646 	va_start(ap, fmt);

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

   648 	va_end(ap);

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

   651 	{

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

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

   654 	} else {

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

   656 		buffer[len] = '\0';

   657 	}

   659 	engine->ClientPrintf(e, buffer);

   660 }

   662 #if SOURCE_ENGINE >= SE_ORANGEBOX

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

   664 {

   665 #else

   666 void PlayerManager::OnClientCommand(edict_t *pEntity)

   667 {

   668 	CCommand args;

   669 #endif

   670 	int client = IndexOfEdict(pEntity);

   671 	cell_t res = Pl_Continue;

   672 	CPlayer *pPlayer = &m_Players[client];

   674 	if (!pPlayer->IsConnected())

   675 	{

   676 		return;

   677 	}

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

   680 	{

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

   682 		{

   683 			g_PluginSys.ListPluginsToClient(pPlayer, args);

   684 			RETURN_META(MRES_SUPERCEDE);

   685 		}

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

   687 		{

   688 			ClientConsolePrint(pEntity,

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

   690 			ClientConsolePrint(pEntity,

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

   692 			ClientConsolePrint(pEntity,

   693 				" Scott \"Damaged Soul\" Ehlert, Matt \"pRED\" Woodrow");

   694 			ClientConsolePrint(pEntity,

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

   696 			ClientConsolePrint(pEntity,

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

   698 			RETURN_META(MRES_SUPERCEDE);

   699 		}

   701 		ClientConsolePrint(pEntity,

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

   703 		ClientConsolePrint(pEntity,

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

   705 		ClientConsolePrint(pEntity,

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

   707 		ClientConsolePrint(pEntity,

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

   709 		RETURN_META(MRES_SUPERCEDE);

   710 	}

   712 	g_HL2.PushCommandStack(&args);

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

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

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

   718 	if (result)

   719 	{

   720 		res = Pl_Handled;

   721 	} else {

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

   723 		if (result)

   724 		{

   725 			res = Pl_Handled;

   726 		}

   727 	}

   729 	if (g_ConsoleDetours.IsEnabled())

   730 	{

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

   732 		if (res2 >= Pl_Stop)

   733 		{

   734 			g_HL2.PopCommandStack();

   735 			RETURN_META(MRES_SUPERCEDE);

   736 		}

   737 		else if (res2 > res)

   738 		{

   739 			res = res2;

   740 		}

   741 	}

   743 	cell_t res2 = Pl_Continue;

   744 	m_clcommand->PushCell(client);

   745 	m_clcommand->PushCell(argcount);

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

   748 	if (res2 > res)

   749 	{

   750 		res = res2;

   751 	}

   753 	if (res >= Pl_Stop)

   754 	{

   755 		g_HL2.PopCommandStack();

   756 		RETURN_META(MRES_SUPERCEDE);

   757 	}

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

   761 	g_HL2.PopCommandStack();

   763 	if (res >= Pl_Handled)

   764 	{

   765 		RETURN_META(MRES_SUPERCEDE);

   766 	}

   767 }

   769 void PlayerManager::OnClientSettingsChanged(edict_t *pEntity)

   770 {

   771 	cell_t res;

   772 	int client = IndexOfEdict(pEntity);

   773 	CPlayer *pPlayer = &m_Players[client];

   775 	if (!pPlayer->IsConnected())

   776 	{

   777 		return;

   778 	}

   780 	m_clinfochanged->PushCell(client);

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

   783 	if (pPlayer->IsFakeClient())

   784 	{

   785 		return;

   786 	}

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

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

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

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

   793 	{

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

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

   796 		{

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

   798 			{

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

   800 				RETURN_META(MRES_IGNORED);

   801 			}

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

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

   804 			{

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

   806 				pPlayer->SetAdminId(INVALID_ADMIN_ID, false);

   807 			}

   808 		}

   809 		pPlayer->SetName(new_name);

   810 	}

   812 	if (m_PassInfoVar.size() > 0)

   813 	{

   814 		/* Try for a password change */

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

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

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

   818 		{

   819 			pPlayer->m_LastPassword.assign(new_pass);

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

   821 			{

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

   823 				pPlayer->DoBasicAdminChecks();

   824 			}

   825 		}

   826 	}

   827 }

   829 int PlayerManager::GetMaxClients()

   830 {

   831 	return m_maxClients;

   832 }

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

   835 {

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

   837 	{

   838 		return NULL;

   839 	}

   840 	return &m_Players[client];

   841 }

   843 int PlayerManager::GetNumPlayers()

   844 {

   845 	return m_PlayerCount;

   846 }

   848 int PlayerManager::GetClientOfUserId(int userid)

   849 {

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

   851 	{

   852 		return 0;

   853 	}

   855 	int client = m_UserIdLookUp[userid];

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

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

   859 	 * check before invoking this backwards compat code.

   860 	 */

   861 	if (client)

   862 	{

   863 		CPlayer *player = GetPlayerByIndex(client);

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

   865 		{

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

   867 			if (realUserId == userid)

   868 			{

   869 				return client;

   870 			}

   871 		}

   872 	}

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

   875 	CPlayer *player;

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

   877 	{

   878 		player = GetPlayerByIndex(i);

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

   880 		{

   881 			continue;

   882 		}

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

   884 		{

   885 			m_UserIdLookUp[userid] = i;

   886 			return i;

   887 		}

   888 	}

   890 	return 0;

   891 }

   893 void PlayerManager::AddClientListener(IClientListener *listener)

   894 {

   895 	m_hooks.push_back(listener);

   896 }

   898 void PlayerManager::RemoveClientListener(IClientListener *listener)

   899 {

   900 	m_hooks.remove(listener);

   901 }

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

   904 {

   905 	int index = IndexOfEdict(pEdict);

   906 	return GetGamePlayer(index);

   907 }

   909 IGamePlayer *PlayerManager::GetGamePlayer(int client)

   910 {

   911 	return GetPlayerByIndex(client);

   912 }

   914 void PlayerManager::ClearAdminId(AdminId id)

   915 {

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

   917 	{

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

   919 		{

   920 			m_Players[i].DumpAdmin(true);

   921 		}

   922 	}

   923 }

   925 void PlayerManager::ClearAllAdmins()

   926 {

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

   928 	{

   929 		m_Players[i].DumpAdmin(true);

   930 	}

   931 }

   933 const char *PlayerManager::GetPassInfoVar()

   934 {

   935 	return m_PassInfoVar.c_str();

   936 }

   938 void PlayerManager::RecheckAnyAdmins()

   939 {

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

   941 	{

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

   943 		{

   944 			m_Players[i].DoBasicAdminChecks();

   945 		}

   946 	}

   947 }

   949 unsigned int PlayerManager::GetReplyTo()

   950 {

   951 	return g_ChatTriggers.GetReplyTo();

   952 }

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

   955 {

   956 	return g_ChatTriggers.SetReplyTo(reply);

   957 }

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

   960 {

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

   962 }

   964 void PlayerManager::RegisterCommandTargetProcessor(ICommandTargetProcessor *pHandler)

   965 {

   966 	target_processors.push_back(pHandler);

   967 }

   969 void PlayerManager::UnregisterCommandTargetProcessor(ICommandTargetProcessor *pHandler)

   970 {

   971 	target_processors.remove(pHandler);

   972 }

   974 void PlayerManager::InvalidatePlayer(CPlayer *pPlayer)

   975 {

   976 	/**

   977 	* Remove client from auth queue if necessary

   978 	*/

   979 	if (!pPlayer->IsAuthorized())

   980 	{

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

   982 		{

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

   984 			{

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

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

   987 				{

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

   989 				}

   990 				/* Remove us and break */

   991 				m_AuthQueue[0]--;

   992 				break;

   993 			}

   994 		}

   995 	}

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

   998 	pPlayer->Disconnect();

   999 }

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

  1002 {

  1003 	if ((flags & COMMAND_FILTER_CONNECTED) == COMMAND_FILTER_CONNECTED

  1004 		&& !pTarget->IsConnected())

  1005 	{

  1006 		return COMMAND_TARGET_NONE;

  1007 	}

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

  1009 		!pTarget->IsInGame())

  1010 	{

  1011 		return COMMAND_TARGET_NOT_IN_GAME;

  1012 	}

  1014 	if ((flags & COMMAND_FILTER_NO_BOTS) == COMMAND_FILTER_NO_BOTS

  1015 		&& pTarget->IsFakeClient())

  1016 	{

  1017 		return COMMAND_TARGET_NOT_HUMAN;

  1018 	}

  1020 	if (pAdmin != NULL)

  1021 	{

  1022 		if ((flags & COMMAND_FILTER_NO_IMMUNITY) != COMMAND_FILTER_NO_IMMUNITY

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

  1024 		{

  1025 			return COMMAND_TARGET_IMMUNE;

  1026 		}

  1027 	}

  1029 	if ((flags & COMMAND_FILTER_ALIVE) == COMMAND_FILTER_ALIVE

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

  1031 	{

  1032 		return COMMAND_TARGET_NOT_ALIVE;

  1033 	}

  1035 	if ((flags & COMMAND_FILTER_DEAD) == COMMAND_FILTER_DEAD

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

  1037 	{

  1038 		return COMMAND_TARGET_NOT_DEAD;

  1039 	}

  1041 	return COMMAND_TARGET_VALID;

  1042 }

  1044 void PlayerManager::ProcessCommandTarget(cmd_target_info_t *info)

  1045 {

  1046 	CPlayer *pTarget, *pAdmin;

  1047 	int max_clients, total = 0;

  1049 	max_clients = GetMaxClients();

  1051 	if (info->max_targets < 1)

  1052 	{

  1053 		info->reason = COMMAND_TARGET_NONE;

  1054 		info->num_targets = 0;

  1055 	}

  1057 	if (info->admin == 0)

  1058 	{

  1059 		pAdmin = NULL;

  1060 	}

  1061 	else

  1062 	{

  1063 		pAdmin = GetPlayerByIndex(info->admin);

  1064 	}

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

  1067 	{

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

  1069 		int client = GetClientOfUserId(userid);

  1071 		/* See if a valid userid matched */

  1072 		if (client > 0)

  1073 		{

  1074 			IGamePlayer *pTarget = GetPlayerByIndex(client);

  1075 			if (pTarget != NULL)

  1076 			{

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

  1078 				{

  1079 					info->targets[0] = client;

  1080 					info->num_targets = 1;

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

  1082 					info->target_name_style = COMMAND_TARGETNAME_RAW;

  1083 				}

  1084 				else

  1085 				{

  1086 					info->num_targets = 0;

  1087 				}

  1088 				return;

  1089 			}

  1090 		}

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

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

  1094 		{

  1095 			size_t p, len;

  1096 			char new_pattern[256];

  1098 			strcpy(new_pattern, "STEAM_");

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

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

  1101 			{

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

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

  1104 				{

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

  1106 				}

  1107 			}

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

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

  1111 			{

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

  1113 				{

  1114 					continue;

  1115 				}

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

  1117 				{

  1118 					continue;

  1119 				}

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

  1121 				{

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

  1123 						== COMMAND_TARGET_VALID)

  1124 					{

  1125 						info->targets[0] = i;

  1126 						info->num_targets = 1;

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

  1128 						info->target_name_style = COMMAND_TARGETNAME_RAW;

  1129 					}

  1130 					else

  1131 					{

  1132 						info->num_targets = 0;

  1133 					}

  1134 					return;

  1135 				}

  1136 			}

  1137 		}

  1139 		/* See if an exact name matches */

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

  1141 		{

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

  1143 			{

  1144 				continue;

  1145 			}

  1146 			if  (!pTarget->IsConnected())

  1147 			{

  1148 				continue;

  1149 			}

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

  1151 			{

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

  1153 					== COMMAND_TARGET_VALID)

  1154 				{

  1155 					info->targets[0] = i;

  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 		}

  1167 	}

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

  1170 	{

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

  1172 		info->num_targets = 1;

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

  1174 		info->target_name_style = COMMAND_TARGETNAME_RAW;

  1175 		return;

  1176 	}

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

  1179 	{

  1180 		bool is_multi = false;

  1181 		bool bots_only = false;

  1182 		int skip_client = -1;

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

  1185 		{

  1186 			is_multi = true;

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

  1188 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1189 		}

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

  1191 		{

  1192 			is_multi = true;

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

  1194 			{

  1195 				info->num_targets = 0;

  1196 				info->reason = COMMAND_TARGET_NOT_ALIVE;

  1197 				return;

  1198 			}

  1199 			info->flags |= COMMAND_FILTER_DEAD;

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

  1201 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1202 		}

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

  1204 		{

  1205 			is_multi = true;

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

  1207 			{

  1208 				info->num_targets = 0;

  1209 				info->reason = COMMAND_TARGET_NOT_DEAD;

  1210 				return;

  1211 			}

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

  1213 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1214 			info->flags |= COMMAND_FILTER_ALIVE;

  1215 		}

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

  1217 		{

  1218 			is_multi = true;

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

  1220 			{

  1221 				info->num_targets = 0;

  1222 				info->reason = COMMAND_FILTER_NO_BOTS;

  1223 				return;

  1224 			}

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

  1226 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1227 			bots_only = true;

  1228 		}

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

  1230 		{

  1231 			is_multi = true;

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

  1233 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1234 			info->flags |= COMMAND_FILTER_NO_BOTS;

  1235 		}

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

  1237 		{

  1238 			is_multi = true;

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

  1240 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1241 			skip_client = info->admin;

  1242 		}

  1244 		if (is_multi)

  1245 		{

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

  1247 			{

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

  1249 				{

  1250 					continue;

  1251 				}

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

  1253 				{

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

  1255 						&& skip_client != i)

  1256 					{

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

  1258 					}

  1259 				}

  1260 			}

  1262 			info->num_targets = total;

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

  1264 			return;

  1265 		}

  1266 	}

  1268 	List<ICommandTargetProcessor *>::iterator iter;

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

  1270 	{

  1271 		ICommandTargetProcessor *pProcessor = (*iter);

  1272 		if (pProcessor->ProcessCommandTarget(info))

  1273 		{

  1274 			return;

  1275 		}

  1276 	}

  1278 	/* Check partial names */

  1279 	int found_client = 0;

  1280 	CPlayer *pFoundClient = NULL;

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

  1282 	{

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

  1284 		{

  1285 			continue;

  1286 		}

  1288 		if (stristr(pTarget->GetName(), info->pattern) != NULL)

  1289 		{

  1290 			if (found_client)

  1291 			{

  1292 				info->num_targets = 0;

  1293 				info->reason = COMMAND_TARGET_AMBIGUOUS;

  1294 				return;

  1295 			}

  1296 			else

  1297 			{

  1298 				found_client = i;

  1299 				pFoundClient = pTarget;

  1300 			}

  1301 		}

  1302 	}

  1304 	if (found_client)

  1305 	{

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

  1307 			== COMMAND_TARGET_VALID)

  1308 		{

  1309 			info->targets[0] = found_client;

  1310 			info->num_targets = 1;

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

  1312 			info->target_name_style = COMMAND_TARGETNAME_RAW;

  1313 		}

  1314 		else

  1315 		{

  1316 			info->num_targets = 0;

  1317 		}

  1318 	}

  1319 	else

  1320 	{

  1321 		info->num_targets = 0;

  1322 		info->reason = COMMAND_TARGET_NONE;

  1323 	}

  1324 }

  1326 void PlayerManager::OnConVarChanged( ConVar *pConVar, const char *oldValue, float flOldValue )

  1327 {

  1328 	if (pConVar->GetBool() && !atoi(oldValue))

  1329 	{

  1330 		MaxPlayersChanged(gpGlobals->maxClients + 1);

  1331 	}

  1332 	else

  1333 	{

  1334 		MaxPlayersChanged();

  1335 	}

  1336 }

  1338 void PlayerManager::OnSourceModMaxPlayersChanged( int newvalue )

  1339 {

  1340 	m_maxClients = newvalue;

  1341 }

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

  1344 {

  1345 	if (!m_FirstPass)

  1346 	{

  1347 		return;

  1348 	}

  1350 	if (newvalue == -1)

  1351 	{

  1352 		newvalue = gpGlobals->maxClients;

  1353 	}

  1355 	if (newvalue == MaxClients())

  1356 	{

  1357 		return;

  1358 	}

  1360 	/* Notify the rest of core */

  1361 	SMGlobalClass *pBase = SMGlobalClass::head;

  1362 	while (pBase)

  1363 	{

  1364 		pBase->OnSourceModMaxPlayersChanged(newvalue);

  1365 		pBase = pBase->m_pGlobalClassNext;

  1366 	}

  1368 	/* Notify Extensions */

  1369 	List<IClientListener *>::iterator iter;

  1370 	IClientListener *pListener = NULL;

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

  1372 	{

  1373 		pListener = (*iter);

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

  1375 		{

  1376 			pListener->OnMaxPlayersChanged(newvalue);

  1377 		}

  1378 	}

  1379 }

  1381 int PlayerManager::GetClientFromSerial(unsigned int serial)

  1382 {

  1383 	serial_t s;

  1384 	s.value = serial;

  1386 	int client = s.bits.index;

  1388 	IGamePlayer *pPlayer = GetGamePlayer(client);

  1390 	if (!pPlayer)

  1391 	{

  1392 		return 0;

  1393 	}

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

  1396 	{

  1397 		return client;

  1398 	}

  1400 	return 0;

  1401 }

  1403 #if SOURCE_ENGINE >= SE_ORANGEBOX

  1404 void CmdMaxplayersCallback(const CCommand &command)

  1405 {

  1406 #else

  1407 void CmdMaxplayersCallback()

  1408 {

  1409 #endif

  1411 	g_Players.MaxPlayersChanged();

  1412 }

  1415 /*******************

  1416  *** PLAYER CODE ***

  1417  *******************/

  1419 CPlayer::CPlayer()

  1420 {

  1421 	m_IsConnected = false;

  1422 	m_IsInGame = false;

  1423 	m_IsAuthorized = false;

  1424 	m_pEdict = NULL;

  1425 	m_Admin = INVALID_ADMIN_ID;

  1426 	m_TempAdmin = false;

  1427 	m_Info = NULL;

  1428 	m_bAdminCheckSignalled = false;

  1429 	m_bIsInKickQueue = false;

  1430 	m_LastPassword.clear();

  1431 	m_LangId = SOURCEMOD_LANGUAGE_ENGLISH;

  1432 	m_bFakeClient = false;

  1433 }

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

  1436 {

  1437 	m_IsConnected = true;

  1438 	m_Name.assign(name);

  1439 	m_Ip.assign(ip);

  1440 	m_pEdict = pEntity;

  1441 	m_iIndex = IndexOfEdict(pEntity);

  1442 	m_LangId = g_Translator.GetServerLanguage();

  1444 	m_Serial.bits.index = m_iIndex;

  1445 	m_Serial.bits.serial = g_PlayerSerialCount++;

  1447 	char ip2[24], *ptr;

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

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

  1450 	{

  1451 		*ptr = '\0';

  1452 	}

  1453 	m_IpNoPort.assign(ip2);

  1454 }

  1456 void CPlayer::Connect()

  1457 {

  1458 	if (m_IsInGame)

  1459 	{

  1460 		return;

  1461 	}

  1463 	m_IsInGame = true;

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

  1466 	int client = IndexOfEdict(m_pEdict);

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

  1468 	{

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

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

  1471 	}

  1472 	else

  1473 	{

  1474 		m_LastPassword.assign("");

  1475 	}

  1476 }

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

  1479 {

  1480 	if (m_IsAuthorized)

  1481 	{

  1482 		return;

  1483 	}

  1485 	m_IsAuthorized = true;

  1486 	m_AuthID.assign(steamid);

  1487 }

  1489 void CPlayer::Disconnect()

  1490 {

  1491 	DumpAdmin(false);

  1492 	m_IsConnected = false;

  1493 	m_IsInGame = false;

  1494 	m_IsAuthorized = false;

  1495 	m_Name.clear();

  1496 	m_Ip.clear();

  1497 	m_AuthID.clear();

  1498 	m_pEdict = NULL;

  1499 	m_Info = NULL;

  1500 	m_bAdminCheckSignalled = false;

  1501 	m_UserId = -1;

  1502 	m_bIsInKickQueue = false;

  1503 	m_bFakeClient = false;

  1504 }

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

  1507 {

  1508 	m_Name.assign(name);

  1509 }

  1511 const char *CPlayer::GetName()

  1512 {

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

  1514 	{

  1515 		return m_Info->GetName();

  1516 	}

  1518 	return m_Name.c_str();

  1519 }

  1521 const char *CPlayer::GetIPAddress()

  1522 {

  1523 	return m_Ip.c_str();

  1524 }

  1526 const char *CPlayer::GetAuthString()

  1527 {

  1528 	return m_AuthID.c_str();

  1529 }

  1531 edict_t *CPlayer::GetEdict()

  1532 {

  1533 	return m_pEdict;

  1534 }

  1536 bool CPlayer::IsInGame()

  1537 {

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

  1539 }

  1541 bool CPlayer::WasCountedAsInGame()

  1542 {

  1543 	return m_IsInGame;

  1544 }

  1546 bool CPlayer::IsConnected()

  1547 {

  1548 	return m_IsConnected;

  1549 }

  1551 bool CPlayer::IsAuthorized()

  1552 {

  1553 	return m_IsAuthorized;

  1554 }

  1556 IPlayerInfo *CPlayer::GetPlayerInfo()

  1557 {

  1558 	if (m_pEdict->GetUnknown())

  1559 	{

  1560 		return m_Info;

  1561 	}

  1563 	return NULL;

  1564 }

  1566 bool CPlayer::IsFakeClient()

  1567 {

  1568 	return m_bFakeClient;

  1569 }

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

  1572 {

  1573 	if (!m_IsConnected)

  1574 	{

  1575 		return;

  1576 	}

  1578 	DumpAdmin(false);

  1580 	m_Admin = id;

  1581 	m_TempAdmin = temporary;

  1582 }

  1584 AdminId CPlayer::GetAdminId()

  1585 {

  1586 	return m_Admin;

  1587 }

  1589 void CPlayer::DumpAdmin(bool deleting)

  1590 {

  1591 	if (m_Admin != INVALID_ADMIN_ID)

  1592 	{

  1593 		if (m_TempAdmin && !deleting)

  1594 		{

  1595 			g_Admins.InvalidateAdmin(m_Admin);

  1596 		}

  1597 		m_Admin = INVALID_ADMIN_ID;

  1598 		m_TempAdmin = false;

  1599 	}

  1600 }

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

  1603 {

  1604 	MarkAsBeingKicked();

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

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

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

  1608 }

  1610 void CPlayer::Authorize_Post()

  1611 {

  1612 	if (m_IsInGame)

  1613 	{

  1614 		DoPostConnectAuthorization();

  1615 	}

  1616 }

  1618 void CPlayer::DoPostConnectAuthorization()

  1619 {

  1620 	bool delay = false;

  1622 	List<IClientListener *>::iterator iter;

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

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

  1625 		 iter++)

  1626 	{

  1627 		IClientListener *pListener = (*iter);

  1628 #if defined MIN_API_FOR_ADMINCALLS

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

  1630 		{

  1631 			continue;

  1632 		}

  1633 #endif

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

  1635 		{

  1636 			delay = true;

  1637 		}

  1638 	}

  1640 	cell_t result = 0;

  1641 	PreAdminCheck->PushCell(m_iIndex);

  1642 	PreAdminCheck->Execute(&result);

  1644 	/* Defer, for better or worse */

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

  1646 	{

  1647 		return;

  1648 	}

  1650 	/* Sanity check */

  1651 	if (!IsConnected())

  1652 	{

  1653 		return;

  1654 	}

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

  1657 	DoBasicAdminChecks();

  1659 	/* Send the notification out */

  1660 	NotifyPostAdminChecks();

  1661 }

  1663 bool CPlayer::RunAdminCacheChecks()

  1664 {

  1665 	AdminId old_id = GetAdminId();

  1667 	DoBasicAdminChecks();

  1669 	return (GetAdminId() != old_id);

  1670 }

  1672 void CPlayer::NotifyPostAdminChecks()

  1673 {

  1674 	if (m_bAdminCheckSignalled)

  1675 	{

  1676 		return;

  1677 	}

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

  1680 	m_bAdminCheckSignalled = true;

  1682 	List<IClientListener *>::iterator iter;

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

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

  1685 		iter++)

  1686 	{

  1687 		IClientListener *pListener = (*iter);

  1688 #if defined MIN_API_FOR_ADMINCALLS

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

  1690 		{

  1691 			continue;

  1692 		}

  1693 #endif

  1694 		pListener->OnClientPostAdminCheck(m_iIndex);

  1695 	}

  1697 	PostAdminFilter->PushCell(m_iIndex);

  1698 	PostAdminFilter->Execute(NULL);

  1700 	PostAdminCheck->PushCell(m_iIndex);

  1701 	PostAdminCheck->Execute(NULL);

  1702 }

  1704 void CPlayer::DoBasicAdminChecks()

  1705 {

  1706 	if (GetAdminId() != INVALID_ADMIN_ID)

  1707 	{

  1708 		return;

  1709 	}

  1711 	/* First check the name */

  1712 	AdminId id;

  1713 	int client = IndexOfEdict(m_pEdict);

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

  1716 	{

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

  1718 		{

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

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

  1721 		}

  1722 		return;

  1723 	}

  1725 	/* Check IP */

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

  1727 	{

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

  1729 		{

  1730 			return;

  1731 		}

  1732 	}

  1734 	/* Check steam id */

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

  1736 	{

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

  1738 		{

  1739 			return;

  1740 		}

  1741 	}

  1742 }

  1744 unsigned int CPlayer::GetLanguageId()

  1745 {

  1746 	return m_LangId;

  1747 }

  1749 int CPlayer::GetUserId()

  1750 {

  1751 	if (m_UserId == -1)

  1752 	{

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

  1754 	}

  1756 	return m_UserId;

  1757 }

  1759 bool CPlayer::IsInKickQueue()

  1760 {

  1761 	return m_bIsInKickQueue;

  1762 }

  1764 void CPlayer::MarkAsBeingKicked()

  1765 {

  1766 	m_bIsInKickQueue = true;

  1767 }

  1769 int CPlayer::GetLifeState()

  1770 {

  1771 	if (lifestate_offset == -1)

  1772 	{

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

  1774 		{

  1775 			lifestate_offset = -2;

  1776 		}

  1777 	}

  1779 	if (lifestate_offset < 0)

  1780 	{

  1781 		IPlayerInfo *info = GetPlayerInfo();

  1782 		if (info == NULL)

  1783 		{

  1784 			return PLAYER_LIFE_UNKNOWN;

  1785 		}

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

  1787 	}

  1789 	if (m_pEdict == NULL)

  1790 	{

  1791 		return PLAYER_LIFE_UNKNOWN;

  1792 	}

  1794 	CBaseEntity *pEntity;

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

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

  1797 	{

  1798 		return PLAYER_LIFE_UNKNOWN;

  1799 	}

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

  1802 	{

  1803 		return PLAYER_LIFE_ALIVE;

  1804 	}

  1805 	else

  1806 	{

  1807 		return PLAYER_LIFE_DEAD;

  1808 	}

  1809 }

  1811 unsigned int CPlayer::GetSerial()

  1812 {

  1813 	return m_Serial.value;

  1814 }

author	David Anderson <dvander@alliedmods.net>
	Fri Oct 02 03:47:42 2009 -0700 (2009-10-02)
changeset 2815	2c7137f077fe
parent 2806	686c283b08fc
child 2827	8293dd8c3247
permissions	-rw-r--r--