sourcemod-central: core/PlayerManager.cpp@70d4ef38b90e

     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 "systems/ExtensionSys.h"

    51 PlayerManager g_Players;

    52 bool g_OnMapStarted = false;

    53 IForward *PreAdminCheck = NULL;

    54 IForward *PostAdminCheck = NULL;

    55 IForward *PostAdminFilter = NULL;

    56 const unsigned int *g_NumPlayersToAuth = NULL;

    57 int lifestate_offset = -1;

    58 List<ICommandTargetProcessor *> target_processors;

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

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

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

    63 #if defined ORANGEBOX_BUILD

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

    65 #else

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

    67 #endif

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

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

    71 #if defined ORANGEBOX_BUILD

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

    73 #else

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

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

    76 #endif

    78 ConCommand *maxplayersCmd = NULL;

    80 class KickPlayerTimer : public ITimedEvent

    81 {

    82 public:

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

    84 	{

    85 		int userid = (int)pData;

    86 		int client = g_Players.GetClientOfUserId(userid);

    87 		if (client)

    88 		{

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

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

    91 		}

    92 		return Pl_Stop;

    93 	}

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

    95 	{

    96 	}

    97 } s_KickPlayerTimer;

    99 PlayerManager::PlayerManager()

   100 {

   101 	m_AuthQueue = NULL;

   102 	m_FirstPass = false;

   103 	m_maxClients = 0;

   105 	m_UserIdLookUp = new int[USHRT_MAX+1];

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

   107 }

   109 PlayerManager::~PlayerManager()

   110 {

   111 	g_NumPlayersToAuth = NULL;

   113 	delete [] m_AuthQueue;

   114 	delete [] m_UserIdLookUp;

   115 }

   117 void PlayerManager::OnSourceModAllInitialized()

   118 {

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

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

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

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

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

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

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

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

   128 	g_ShareSys.AddInterface(NULL, this);

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

   131 	ParamType p2[] = {Param_Cell};

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

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

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

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

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

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

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

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

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

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

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

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

   147 	m_bIsListenServer = !engine->IsDedicatedServer();

   148 	m_ListenClient = 0;

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

   152 	ConCommandBase *pBase = icvar->GetCommands();

   153 	ConCommand *pCmd = NULL;

   154 	while (pBase)

   155 	{

   156 		if (strcmp(pBase->GetName(), "maxplayers") == 0)

   157 		{

   158 			/* Don't want to return convar with same name */

   159 			if (!pBase->IsCommand())

   160 			{

   161 				break;

   162 			}

   164 			pCmd = (ConCommand *)pBase;

   165 			break;

   166 		}

   167 		pBase = const_cast<ConCommandBase *>(pBase->GetNext());

   168 	}

   170 	if (pCmd != NULL)

   171 	{

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

   173 		maxplayersCmd = pCmd;

   174 	}

   175 }

   177 void PlayerManager::OnSourceModShutdown()

   178 {

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

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

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

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

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

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

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

   187 	/* Release forwards */

   188 	g_Forwards.ReleaseForward(m_clconnect);

   189 	g_Forwards.ReleaseForward(m_clputinserver);

   190 	g_Forwards.ReleaseForward(m_cldisconnect);

   191 	g_Forwards.ReleaseForward(m_cldisconnect_post);

   192 	g_Forwards.ReleaseForward(m_clcommand);

   193 	g_Forwards.ReleaseForward(m_clinfochanged);

   194 	g_Forwards.ReleaseForward(m_clauth);

   195 	g_Forwards.ReleaseForward(m_onActivate);

   196 	g_Forwards.ReleaseForward(m_onActivate2);

   198 	g_Forwards.ReleaseForward(PreAdminCheck);

   199 	g_Forwards.ReleaseForward(PostAdminCheck);

   200 	g_Forwards.ReleaseForward(PostAdminFilter);

   202 	delete [] m_Players;

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

   206 	if (maxplayersCmd != NULL)

   207 	{

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

   209 	}

   210 }

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

   213 												 const char *value,

   214 												 ConfigSource source,

   215 												 char *error,

   216 												 size_t maxlength)

   217 {

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

   219 	{

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

   221 		{

   222 			m_PassInfoVar.assign(value);

   223 		}

   224 		return ConfigResult_Accept;

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

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

   227 		{

   228 			m_QueryLang = true;

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

   230 			m_QueryLang = false;

   231 		} else {

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

   233 			return ConfigResult_Reject;

   234 		}

   235 		return ConfigResult_Accept;

   236 	}

   237 	return ConfigResult_Ignore;

   238 }

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

   241 {

   242 	if (!m_FirstPass)

   243 	{

   244 		/* Initialize all players */

   245 		m_maxClients = clientMax;

   246 		m_PlayerCount = 0;

   247 		m_Players = new CPlayer[ABSOLUTE_PLAYER_LIMIT + 1];

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

   249 		m_FirstPass = true;

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

   253 		g_NumPlayersToAuth = &m_AuthQueue[0];

   255 		g_PluginSys.SyncMaxClients(clientMax);

   256 	}

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

   258 	m_onActivate->Execute(NULL);

   259 	m_onActivate2->Execute(NULL);

   261 	List<IClientListener *>::iterator iter;

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

   263 	{

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

   265 		{

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

   267 		}

   268 	}

   270 	g_OnMapStarted = true;

   272 	SM_ExecuteAllConfigs();

   273 }

   275 bool PlayerManager::IsServerActivated()

   276 {

   277 	return m_FirstPass;

   278 }

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

   281 {

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

   283 	if (password != NULL)

   284 	{

   285 		if (m_PassInfoVar.size() < 1)

   286 		{

   287 			return false;

   288 		}

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

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

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

   293 		{

   294 			return false;

   295 		}

   296 	}

   298 	pPlayer->SetAdminId(id, false);

   300 	return true;

   301 }

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

   304 {

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

   306 	if (password == NULL)

   307 	{

   308 		return false;

   309 	}

   311 	if (m_PassInfoVar.size() < 1)

   312 	{

   313 		return false;

   314 	}

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

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

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

   319 	{

   320 		return false;

   321 	}

   323 	pPlayer->SetAdminId(id, false);

   325 	return true;

   326 }

   328 void PlayerManager::RunAuthChecks()

   329 {

   330 	CPlayer *pPlayer;

   331 	const char *authstr;

   332 	unsigned int removed = 0;

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

   334 	{

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

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

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

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

   339 		{

   340 			/* Set authorization */

   341 			pPlayer->Authorize(authstr);

   343 			/* Mark as removed from queue */

   344 			unsigned int client = m_AuthQueue[i];

   345 			m_AuthQueue[i] = 0;

   346 			removed++;

   348 			/* Send to extensions */

   349 			List<IClientListener *>::iterator iter;

   350 			IClientListener *pListener;

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

   352 			{

   353 				pListener = (*iter);

   354 				pListener->OnClientAuthorized(client, authstr);

   355 				if (!pPlayer->IsConnected())

   356 				{

   357 					break;

   358 				}

   359 			}

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

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

   363 			{

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

   365 				m_clauth->PushCell(client);

   366 				m_clauth->PushString(authstr);

   367 				m_clauth->Execute(NULL);

   368 			}

   370 			if (pPlayer->IsConnected())

   371 			{

   372 				pPlayer->Authorize_Post();

   373 			}

   374 		}

   375 	}

   377 	/* Clean up the queue */

   378 	if (removed)

   379 	{

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

   381 		if (removed != m_AuthQueue[0])

   382 		{

   383 			unsigned int diff = 0;

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

   385 			{

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

   387 				if (m_AuthQueue[i] == 0)

   388 				{

   389 					/* Increase the differential */

   390 					diff++;

   391 				} else {

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

   393 					assert(i > diff);

   394 					assert(i - diff >= 1);

   395 					/* move this index down */

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

   397 				}

   398 			}

   399 			m_AuthQueue[0] -= removed;

   400 		} else {

   401 			m_AuthQueue[0] = 0;

   402 		}

   403 	}

   404 }

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

   407 {

   408 	int client = engine->IndexOfEdict(pEntity);

   409 	CPlayer *pPlayer = &m_Players[client];

   411 	List<IClientListener *>::iterator iter;

   412 	IClientListener *pListener = NULL;

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

   414 	{

   415 		pListener = (*iter);

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

   417 		{

   418 			return false;

   419 		}

   420 	}

   422 	cell_t res = 1;

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

   425 	m_clconnect->PushCell(client);

   426 	m_clconnect->PushStringEx(reject, maxrejectlen, SM_PARAM_STRING_UTF8, SM_PARAM_COPYBACK);

   427 	m_clconnect->PushCell(maxrejectlen);

   428 	m_clconnect->Execute(&res);

   430 	if (res)

   431 	{

   432 		if (!pPlayer->IsAuthorized())

   433 		{

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

   435 		}

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

   438 	}

   439 	else

   440 	{

   441 		if (!pPlayer->IsFakeClient())

   442 		{

   443 			RETURN_META_VALUE(MRES_SUPERCEDE, false);

   444 		}

   445 	}

   447 	return true;

   448 }

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

   451 {

   452 	int client = engine->IndexOfEdict(pEntity);

   453 	bool orig_value = META_RESULT_ORIG_RET(bool);

   454 	CPlayer *pPlayer = &m_Players[client];

   456 	if (orig_value)

   457 	{

   458 		List<IClientListener *>::iterator iter;

   459 		IClientListener *pListener = NULL;

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

   461 		{

   462 			pListener = (*iter);

   463 			pListener->OnClientConnected(client);

   464 			if (!pPlayer->IsConnected())

   465 			{

   466 				break;

   467 			}

   468 		}

   470 		if (!pPlayer->IsFakeClient()

   471 			&& m_bIsListenServer

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

   473 		{

   474 			m_ListenClient = client;

   475 		}

   476 	}

   477 	else

   478 	{

   479 		InvalidatePlayer(pPlayer);

   480 	}

   482 	return true;

   483 }

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

   486 {

   487 	cell_t res;

   488 	int client = engine->IndexOfEdict(pEntity);

   489 	CPlayer *pPlayer = &m_Players[client];

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

   492 	if (!pPlayer->IsConnected())

   493 	{

   494 		/* Run manual connection routines */

   495 		char error[255];

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

   497 		pPlayer->Authorize(authid);

   498 		pPlayer->m_bFakeClient = true;

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

   500 		{

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

   502 			return;

   503 		}

   504 		List<IClientListener *>::iterator iter;

   505 		IClientListener *pListener = NULL;

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

   507 		{

   508 			pListener = (*iter);

   509 			pListener->OnClientConnected(client);

   510 			/* See if bot was kicked */

   511 			if (!pPlayer->IsConnected())

   512 			{

   513 				return;

   514 			}

   515 		}

   516 		/* Now do authorization */

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

   518 		{

   519 			pListener = (*iter);

   520 			pListener->OnClientAuthorized(client, authid);

   521 		}

   522 		/* Finally, tell plugins */

   523 		if (m_clauth->GetFunctionCount())

   524 		{

   525 			m_clauth->PushCell(client);

   526 			m_clauth->PushString(authid);

   527 			m_clauth->Execute(NULL);

   528 		}

   529 		pPlayer->Authorize_Post();

   530 	}

   532 	if (playerinfo)

   533 	{

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

   535 	}

   537 	/* Get the client's language */

   538 	if (m_QueryLang)

   539 	{

   540 		const char *name;

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

   542 		{

   543 			unsigned int langid;

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

   545 		} else {

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

   547 		}

   548 	}

   550 	pPlayer->Connect();

   551 	m_PlayerCount++;

   553 	List<IClientListener *>::iterator iter;

   554 	IClientListener *pListener = NULL;

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

   556 	{

   557 		pListener = (*iter);

   558 		pListener->OnClientPutInServer(client);

   559 	}

   561 	m_clputinserver->PushCell(client);

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

   564 	if (pPlayer->IsAuthorized())

   565 	{

   566 		pPlayer->DoPostConnectAuthorization();

   567 	}

   568 }

   570 void PlayerManager::OnSourceModLevelEnd()

   571 {

   572 	/* Disconnect all bots still in game */

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

   574 	{

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

   576 		{

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

   578 		}

   579 	}

   580 	m_PlayerCount = 0;

   581 }

   583 void PlayerManager::OnClientDisconnect(edict_t *pEntity)

   584 {

   585 	cell_t res;

   586 	int client = engine->IndexOfEdict(pEntity);

   587 	CPlayer *pPlayer = &m_Players[client];

   589 	if (pPlayer->IsConnected())

   590 	{

   591 		m_cldisconnect->PushCell(client);

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

   593 	}

   594 	else

   595 	{

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

   597 		return;

   598 	}

   600 	if (pPlayer->WasCountedAsInGame())

   601 	{

   602 		m_PlayerCount--;

   603 	}

   605 	List<IClientListener *>::iterator iter;

   606 	IClientListener *pListener = NULL;

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

   608 	{

   609 		pListener = (*iter);

   610 		pListener->OnClientDisconnecting(client);

   611 	}

   613 	InvalidatePlayer(pPlayer);

   615 	if (m_ListenClient == client)

   616 	{

   617 		m_ListenClient = 0;

   618 	}

   619 }

   621 void PlayerManager::OnClientDisconnect_Post(edict_t *pEntity)

   622 {

   623 	cell_t res;

   624 	int client = engine->IndexOfEdict(pEntity);

   626 	m_cldisconnect_post->PushCell(client);

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

   629 	List<IClientListener *>::iterator iter;

   630 	IClientListener *pListener = NULL;

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

   632 	{

   633 		pListener = (*iter);

   634 		pListener->OnClientDisconnected(client);

   635 	}

   636 }

   638 #if defined ORANGEBOX_BUILD

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

   640 {

   641 #else

   642 void PlayerManager::OnClientCommand(edict_t *pEntity)

   643 {

   644 	CCommand args;

   645 #endif

   646 	int client = engine->IndexOfEdict(pEntity);

   647 	cell_t res = Pl_Continue;

   648 	CPlayer *pPlayer = &m_Players[client];

   650 	if (!pPlayer->IsConnected())

   651 	{

   652 		return;

   653 	}

   655 	g_HL2.PushCommandStack(&args);

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

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

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

   661 	if (result)

   662 	{

   663 		res = Pl_Handled;

   664 	} else {

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

   666 		if (result)

   667 		{

   668 			res = Pl_Handled;

   669 		}

   670 	}

   672 	cell_t res2 = Pl_Continue;

   673 	m_clcommand->PushCell(client);

   674 	m_clcommand->PushCell(argcount);

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

   677 	if (res2 > res)

   678 	{

   679 		res = res2;

   680 	}

   682 	if (res >= Pl_Stop)

   683 	{

   684 		g_HL2.PopCommandStack();

   685 		RETURN_META(MRES_SUPERCEDE);

   686 	}

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

   690 	g_HL2.PopCommandStack();

   692 	if (res >= Pl_Handled)

   693 	{

   694 		RETURN_META(MRES_SUPERCEDE);

   695 	}

   696 }

   698 void PlayerManager::OnClientSettingsChanged(edict_t *pEntity)

   699 {

   700 	cell_t res;

   701 	int client = engine->IndexOfEdict(pEntity);

   702 	CPlayer *pPlayer = &m_Players[client];

   704 	if (!pPlayer->IsConnected())

   705 	{

   706 		return;

   707 	}

   709 	m_clinfochanged->PushCell(engine->IndexOfEdict(pEntity));

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

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

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

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

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

   717 	{

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

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

   720 		{

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

   722 			{

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

   724 				RETURN_META(MRES_IGNORED);

   725 			}

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

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

   728 			{

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

   730 				pPlayer->SetAdminId(INVALID_ADMIN_ID, false);

   731 			}

   732 		}

   733 		pPlayer->SetName(new_name);

   734 	}

   736 	if (m_PassInfoVar.size() > 0)

   737 	{

   738 		/* Try for a password change */

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

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

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

   742 		{

   743 			pPlayer->m_LastPassword.assign(new_pass);

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

   745 			{

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

   747 				pPlayer->DoBasicAdminChecks();

   748 			}

   749 		}

   750 	}

   751 }

   753 int PlayerManager::GetMaxClients()

   754 {

   755 	return m_maxClients;

   756 }

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

   759 {

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

   761 	{

   762 		return NULL;

   763 	}

   764 	return &m_Players[client];

   765 }

   767 int PlayerManager::GetNumPlayers()

   768 {

   769 	return m_PlayerCount;

   770 }

   772 int PlayerManager::GetClientOfUserId(int userid)

   773 {

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

   775 	{

   776 		return 0;

   777 	}

   779 	int client = m_UserIdLookUp[userid];

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

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

   783 	 * check before invoking this backwards compat code.

   784 	 */

   785 	if (client)

   786 	{

   787 		CPlayer *player = GetPlayerByIndex(client);

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

   789 		{

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

   791 			if (realUserId == userid)

   792 			{

   793 				return client;

   794 			}

   795 		}

   796 	}

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

   799 	CPlayer *player;

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

   801 	{

   802 		player = GetPlayerByIndex(i);

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

   804 		{

   805 			continue;

   806 		}

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

   808 		{

   809 			m_UserIdLookUp[userid] = i;

   810 			return i;

   811 		}

   812 	}

   814 	return 0;

   815 }

   817 void PlayerManager::AddClientListener(IClientListener *listener)

   818 {

   819 	m_hooks.push_back(listener);

   820 }

   822 void PlayerManager::RemoveClientListener(IClientListener *listener)

   823 {

   824 	m_hooks.remove(listener);

   825 }

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

   828 {

   829 	int index = engine->IndexOfEdict(pEdict);

   830 	return GetGamePlayer(index);

   831 }

   833 IGamePlayer *PlayerManager::GetGamePlayer(int client)

   834 {

   835 	return GetPlayerByIndex(client);

   836 }

   838 void PlayerManager::ClearAdminId(AdminId id)

   839 {

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

   841 	{

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

   843 		{

   844 			m_Players[i].DumpAdmin(true);

   845 		}

   846 	}

   847 }

   849 void PlayerManager::ClearAllAdmins()

   850 {

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

   852 	{

   853 		m_Players[i].DumpAdmin(true);

   854 	}

   855 }

   857 const char *PlayerManager::GetPassInfoVar()

   858 {

   859 	return m_PassInfoVar.c_str();

   860 }

   862 void PlayerManager::RecheckAnyAdmins()

   863 {

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

   865 	{

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

   867 		{

   868 			m_Players[i].DoBasicAdminChecks();

   869 		}

   870 	}

   871 }

   873 unsigned int PlayerManager::GetReplyTo()

   874 {

   875 	return g_ChatTriggers.GetReplyTo();

   876 }

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

   879 {

   880 	return g_ChatTriggers.SetReplyTo(reply);

   881 }

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

   884 {

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

   886 }

   888 void PlayerManager::RegisterCommandTargetProcessor(ICommandTargetProcessor *pHandler)

   889 {

   890 	target_processors.push_back(pHandler);

   891 }

   893 void PlayerManager::UnregisterCommandTargetProcessor(ICommandTargetProcessor *pHandler)

   894 {

   895 	target_processors.remove(pHandler);

   896 }

   898 void PlayerManager::InvalidatePlayer(CPlayer *pPlayer)

   899 {

   900 	/**

   901 	* Remove client from auth queue if necessary

   902 	*/

   903 	if (!pPlayer->IsAuthorized())

   904 	{

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

   906 		{

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

   908 			{

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

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

   911 				{

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

   913 				}

   914 				/* Remove us and break */

   915 				m_AuthQueue[0]--;

   916 				break;

   917 			}

   918 		}

   919 	}

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

   922 	pPlayer->Disconnect();

   923 }

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

   926 {

   927 	if ((flags & COMMAND_FILTER_CONNECTED) == COMMAND_FILTER_CONNECTED

   928 		&& !pTarget->IsConnected())

   929 	{

   930 		return COMMAND_TARGET_NONE;

   931 	}

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

   933 		!pTarget->IsInGame())

   934 	{

   935 		return COMMAND_TARGET_NOT_IN_GAME;

   936 	}

   938 	if ((flags & COMMAND_FILTER_NO_BOTS) == COMMAND_FILTER_NO_BOTS

   939 		&& pTarget->IsFakeClient())

   940 	{

   941 		return COMMAND_TARGET_NOT_HUMAN;

   942 	}

   944 	if (pAdmin != NULL)

   945 	{

   946 		if ((flags & COMMAND_FILTER_NO_IMMUNITY) != COMMAND_FILTER_NO_IMMUNITY

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

   948 		{

   949 			return COMMAND_TARGET_IMMUNE;

   950 		}

   951 	}

   953 	if ((flags & COMMAND_FILTER_ALIVE) == COMMAND_FILTER_ALIVE

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

   955 	{

   956 		return COMMAND_TARGET_NOT_ALIVE;

   957 	}

   959 	if ((flags & COMMAND_FILTER_DEAD) == COMMAND_FILTER_DEAD

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

   961 	{

   962 		return COMMAND_TARGET_NOT_DEAD;

   963 	}

   965 	return COMMAND_TARGET_VALID;

   966 }

   968 void PlayerManager::ProcessCommandTarget(cmd_target_info_t *info)

   969 {

   970 	CPlayer *pTarget, *pAdmin;

   971 	int max_clients, total = 0;

   973 	max_clients = GetMaxClients();

   975 	if (info->max_targets < 1)

   976 	{

   977 		info->reason = COMMAND_TARGET_NONE;

   978 		info->num_targets = 0;

   979 	}

   981 	if (info->admin == 0)

   982 	{

   983 		pAdmin = NULL;

   984 	}

   985 	else

   986 	{

   987 		pAdmin = GetPlayerByIndex(info->admin);

   988 	}

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

   991 	{

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

   993 		int client = GetClientOfUserId(userid);

   995 		/* See if a valid userid matched */

   996 		if (client > 0)

   997 		{

   998 			IGamePlayer *pTarget = GetPlayerByIndex(client);

   999 			if (pTarget != NULL)

  1000 			{

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

  1002 				{

  1003 					info->targets[0] = client;

  1004 					info->num_targets = 1;

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

  1006 					info->target_name_style = COMMAND_TARGETNAME_RAW;

  1007 				}

  1008 				else

  1009 				{

  1010 					info->num_targets = 0;

  1011 				}

  1012 				return;

  1013 			}

  1014 		}

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

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

  1018 		{

  1019 			size_t p, len;

  1020 			char new_pattern[256];

  1022 			strcpy(new_pattern, "STEAM_");

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

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

  1025 			{

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

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

  1028 				{

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

  1030 				}

  1031 			}

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

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

  1035 			{

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

  1037 				{

  1038 					continue;

  1039 				}

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

  1041 				{

  1042 					continue;

  1043 				}

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

  1045 				{

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

  1047 						== COMMAND_TARGET_VALID)

  1048 					{

  1049 						info->targets[0] = i;

  1050 						info->num_targets = 1;

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

  1052 						info->target_name_style = COMMAND_TARGETNAME_RAW;

  1053 					}

  1054 					else

  1055 					{

  1056 						info->num_targets = 0;

  1057 					}

  1058 					return;

  1059 				}

  1060 			}

  1061 		}

  1063 		/* See if an exact name matches */

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

  1065 		{

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

  1067 			{

  1068 				continue;

  1069 			}

  1070 			if  (!pTarget->IsConnected())

  1071 			{

  1072 				continue;

  1073 			}

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

  1075 			{

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

  1077 					== COMMAND_TARGET_VALID)

  1078 				{

  1079 					info->targets[0] = i;

  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 		}

  1091 	}

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

  1094 	{

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

  1096 		info->num_targets = 1;

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

  1098 		info->target_name_style = COMMAND_TARGETNAME_RAW;

  1099 		return;

  1100 	}

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

  1103 	{

  1104 		bool is_multi = false;

  1105 		bool bots_only = false;

  1106 		int skip_client = -1;

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

  1109 		{

  1110 			is_multi = true;

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

  1112 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1113 		}

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

  1115 		{

  1116 			is_multi = true;

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

  1118 			{

  1119 				info->num_targets = 0;

  1120 				info->reason = COMMAND_TARGET_NOT_ALIVE;

  1121 				return;

  1122 			}

  1123 			info->flags |= COMMAND_FILTER_DEAD;

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

  1125 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1126 		}

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

  1128 		{

  1129 			is_multi = true;

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

  1131 			{

  1132 				info->num_targets = 0;

  1133 				info->reason = COMMAND_TARGET_NOT_DEAD;

  1134 				return;

  1135 			}

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

  1137 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1138 			info->flags |= COMMAND_FILTER_ALIVE;

  1139 		}

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

  1141 		{

  1142 			is_multi = true;

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

  1144 			{

  1145 				info->num_targets = 0;

  1146 				info->reason = COMMAND_FILTER_NO_BOTS;

  1147 				return;

  1148 			}

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

  1150 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1151 			bots_only = true;

  1152 		}

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

  1154 		{

  1155 			is_multi = true;

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

  1157 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1158 			info->flags |= COMMAND_FILTER_NO_BOTS;

  1159 		}

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

  1161 		{

  1162 			is_multi = true;

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

  1164 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1165 			skip_client = info->admin;

  1166 		}

  1168 		if (is_multi)

  1169 		{

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

  1171 			{

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

  1173 				{

  1174 					continue;

  1175 				}

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

  1177 				{

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

  1179 						&& skip_client != i)

  1180 					{

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

  1182 					}

  1183 				}

  1184 			}

  1186 			info->num_targets = total;

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

  1188 			return;

  1189 		}

  1190 	}

  1192 	List<ICommandTargetProcessor *>::iterator iter;

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

  1194 	{

  1195 		ICommandTargetProcessor *pProcessor = (*iter);

  1196 		if (pProcessor->ProcessCommandTarget(info))

  1197 		{

  1198 			return;

  1199 		}

  1200 	}

  1202 	/* Check partial names */

  1203 	int found_client = 0;

  1204 	CPlayer *pFoundClient = NULL;

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

  1206 	{

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

  1208 		{

  1209 			continue;

  1210 		}

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

  1213 		{

  1214 			if (found_client)

  1215 			{

  1216 				info->num_targets = 0;

  1217 				info->reason = COMMAND_TARGET_AMBIGUOUS;

  1218 				return;

  1219 			}

  1220 			else

  1221 			{

  1222 				found_client = i;

  1223 				pFoundClient = pTarget;

  1224 			}

  1225 		}

  1226 	}

  1228 	if (found_client)

  1229 	{

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

  1231 			== COMMAND_TARGET_VALID)

  1232 		{

  1233 			info->targets[0] = found_client;

  1234 			info->num_targets = 1;

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

  1236 			info->target_name_style = COMMAND_TARGETNAME_RAW;

  1237 		}

  1238 		else

  1239 		{

  1240 			info->num_targets = 0;

  1241 		}

  1242 	}

  1243 	else

  1244 	{

  1245 		info->num_targets = 0;

  1246 		info->reason = COMMAND_TARGET_NONE;

  1247 	}

  1248 }

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

  1251 {

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

  1253 	{

  1254 		MaxPlayersChanged(gpGlobals->maxClients + 1);

  1255 	}

  1256 	else

  1257 	{

  1258 		MaxPlayersChanged();

  1259 	}

  1260 }

  1262 void PlayerManager::OnSourceModMaxPlayersChanged( int newvalue )

  1263 {

  1264 	m_maxClients = newvalue;

  1265 }

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

  1268 {

  1269 	if (newvalue == -1)

  1270 	{

  1271 		newvalue = gpGlobals->maxClients;

  1272 	}

  1274 	if (newvalue == MaxClients())

  1275 	{

  1276 		return;

  1277 	}

  1279 	/* Notify the rest of core */

  1280 	SMGlobalClass *pBase = SMGlobalClass::head;

  1281 	while (pBase)

  1282 	{

  1283 		pBase->OnSourceModMaxPlayersChanged(newvalue);

  1284 		pBase = pBase->m_pGlobalClassNext;

  1285 	}

  1287 	/* Notify Extensions */

  1288 	List<IClientListener *>::iterator iter;

  1289 	IClientListener *pListener = NULL;

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

  1291 	{

  1292 		pListener = (*iter);

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

  1294 		{

  1295 			pListener->OnMaxPlayersChanged(newvalue);

  1296 		}

  1297 	}

  1298 }

  1300 #if defined ORANGEBOX_BUILD

  1301 void CmdMaxplayersCallback(const CCommand &command)

  1302 {

  1303 #else

  1304 void CmdMaxplayersCallback()

  1305 {

  1306 #endif

  1308 	g_Players.MaxPlayersChanged();

  1309 }

  1312 /*******************

  1313  *** PLAYER CODE ***

  1314  *******************/

  1316 CPlayer::CPlayer()

  1317 {

  1318 	m_IsConnected = false;

  1319 	m_IsInGame = false;

  1320 	m_IsAuthorized = false;

  1321 	m_pEdict = NULL;

  1322 	m_Admin = INVALID_ADMIN_ID;

  1323 	m_TempAdmin = false;

  1324 	m_Info = NULL;

  1325 	m_bAdminCheckSignalled = false;

  1326 	m_bIsInKickQueue = false;

  1327 	m_LastPassword.clear();

  1328 	m_LangId = SOURCEMOD_LANGUAGE_ENGLISH;

  1329 	m_bFakeClient = false;

  1330 }

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

  1333 {

  1334 	m_IsConnected = true;

  1335 	m_Name.assign(name);

  1336 	m_Ip.assign(ip);

  1337 	m_pEdict = pEntity;

  1338 	m_iIndex = engine->IndexOfEdict(pEntity);

  1339 	m_LangId = g_Translator.GetServerLanguage();

  1341 	char ip2[24], *ptr;

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

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

  1344 	{

  1345 		*ptr = '\0';

  1346 	}

  1347 	m_IpNoPort.assign(ip2);

  1348 }

  1350 void CPlayer::Connect()

  1351 {

  1352 	if (m_IsInGame)

  1353 	{

  1354 		return;

  1355 	}

  1357 	m_IsInGame = true;

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

  1360 	int client = engine->IndexOfEdict(m_pEdict);

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

  1362 	{

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

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

  1365 	}

  1366 	else

  1367 	{

  1368 		m_LastPassword.assign("");

  1369 	}

  1370 }

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

  1373 {

  1374 	if (m_IsAuthorized)

  1375 	{

  1376 		return;

  1377 	}

  1379 	m_IsAuthorized = true;

  1380 	m_AuthID.assign(steamid);

  1381 }

  1383 void CPlayer::Disconnect()

  1384 {

  1385 	DumpAdmin(false);

  1386 	m_IsConnected = false;

  1387 	m_IsInGame = false;

  1388 	m_IsAuthorized = false;

  1389 	m_Name.clear();

  1390 	m_Ip.clear();

  1391 	m_AuthID.clear();

  1392 	m_pEdict = NULL;

  1393 	m_Info = NULL;

  1394 	m_bAdminCheckSignalled = false;

  1395 	m_UserId = -1;

  1396 	m_bIsInKickQueue = false;

  1397 	m_bFakeClient = false;

  1398 }

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

  1401 {

  1402 	m_Name.assign(name);

  1403 }

  1405 const char *CPlayer::GetName()

  1406 {

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

  1408 	{

  1409 		return m_Info->GetName();

  1410 	}

  1412 	return m_Name.c_str();

  1413 }

  1415 const char *CPlayer::GetIPAddress()

  1416 {

  1417 	return m_Ip.c_str();

  1418 }

  1420 const char *CPlayer::GetAuthString()

  1421 {

  1422 	return m_AuthID.c_str();

  1423 }

  1425 edict_t *CPlayer::GetEdict()

  1426 {

  1427 	return m_pEdict;

  1428 }

  1430 bool CPlayer::IsInGame()

  1431 {

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

  1433 }

  1435 bool CPlayer::WasCountedAsInGame()

  1436 {

  1437 	return m_IsInGame;

  1438 }

  1440 bool CPlayer::IsConnected()

  1441 {

  1442 	return m_IsConnected;

  1443 }

  1445 bool CPlayer::IsAuthorized()

  1446 {

  1447 	return m_IsAuthorized;

  1448 }

  1450 IPlayerInfo *CPlayer::GetPlayerInfo()

  1451 {

  1452 	if (m_pEdict->GetUnknown())

  1453 	{

  1454 		return m_Info;

  1455 	}

  1457 	return NULL;

  1458 }

  1460 bool CPlayer::IsFakeClient()

  1461 {

  1462 	return m_bFakeClient;

  1463 }

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

  1466 {

  1467 	if (!m_IsConnected)

  1468 	{

  1469 		return;

  1470 	}

  1472 	DumpAdmin(false);

  1474 	m_Admin = id;

  1475 	m_TempAdmin = temporary;

  1476 }

  1478 AdminId CPlayer::GetAdminId()

  1479 {

  1480 	return m_Admin;

  1481 }

  1483 void CPlayer::DumpAdmin(bool deleting)

  1484 {

  1485 	if (m_Admin != INVALID_ADMIN_ID)

  1486 	{

  1487 		if (m_TempAdmin && !deleting)

  1488 		{

  1489 			g_Admins.InvalidateAdmin(m_Admin);

  1490 		}

  1491 		m_Admin = INVALID_ADMIN_ID;

  1492 		m_TempAdmin = false;

  1493 	}

  1494 }

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

  1497 {

  1498 	MarkAsBeingKicked();

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

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

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

  1502 }

  1504 void CPlayer::Authorize_Post()

  1505 {

  1506 	if (m_IsInGame)

  1507 	{

  1508 		DoPostConnectAuthorization();

  1509 	}

  1510 }

  1512 void CPlayer::DoPostConnectAuthorization()

  1513 {

  1514 	bool delay = false;

  1516 	List<IClientListener *>::iterator iter;

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

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

  1519 		 iter++)

  1520 	{

  1521 		IClientListener *pListener = (*iter);

  1522 #if defined MIN_API_FOR_ADMINCALLS

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

  1524 		{

  1525 			continue;

  1526 		}

  1527 #endif

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

  1529 		{

  1530 			delay = true;

  1531 		}

  1532 	}

  1534 	cell_t result = 0;

  1535 	PreAdminCheck->PushCell(m_iIndex);

  1536 	PreAdminCheck->Execute(&result);

  1538 	/* Defer, for better or worse */

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

  1540 	{

  1541 		return;

  1542 	}

  1544 	/* Sanity check */

  1545 	if (!IsConnected())

  1546 	{

  1547 		return;

  1548 	}

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

  1551 	DoBasicAdminChecks();

  1553 	/* Send the notification out */

  1554 	NotifyPostAdminChecks();

  1555 }

  1557 bool CPlayer::RunAdminCacheChecks()

  1558 {

  1559 	AdminId old_id = GetAdminId();

  1561 	DoBasicAdminChecks();

  1563 	return (GetAdminId() != old_id);

  1564 }

  1566 void CPlayer::NotifyPostAdminChecks()

  1567 {

  1568 	if (m_bAdminCheckSignalled)

  1569 	{

  1570 		return;

  1571 	}

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

  1574 	m_bAdminCheckSignalled = true;

  1576 	List<IClientListener *>::iterator iter;

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

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

  1579 		iter++)

  1580 	{

  1581 		IClientListener *pListener = (*iter);

  1582 #if defined MIN_API_FOR_ADMINCALLS

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

  1584 		{

  1585 			continue;

  1586 		}

  1587 #endif

  1588 		pListener->OnClientPostAdminCheck(m_iIndex);

  1589 	}

  1591 	PostAdminFilter->PushCell(m_iIndex);

  1592 	PostAdminFilter->Execute(NULL);

  1594 	PostAdminCheck->PushCell(m_iIndex);

  1595 	PostAdminCheck->Execute(NULL);

  1596 }

  1598 void CPlayer::DoBasicAdminChecks()

  1599 {

  1600 	if (GetAdminId() != INVALID_ADMIN_ID)

  1601 	{

  1602 		return;

  1603 	}

  1605 	/* First check the name */

  1606 	AdminId id;

  1607 	int client = engine->IndexOfEdict(m_pEdict);

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

  1610 	{

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

  1612 		{

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

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

  1615 		}

  1616 		return;

  1617 	}

  1619 	/* Check IP */

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

  1621 	{

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

  1623 		{

  1624 			return;

  1625 		}

  1626 	}

  1628 	/* Check IP address */

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

  1630 	{

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

  1632 		{

  1633 			return;

  1634 		}

  1635 	}

  1636 }

  1638 unsigned int CPlayer::GetLanguageId()

  1639 {

  1640 	return m_LangId;

  1641 }

  1643 int CPlayer::GetUserId()

  1644 {

  1645 	if (m_UserId == -1)

  1646 	{

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

  1648 	}

  1650 	return m_UserId;

  1651 }

  1653 bool CPlayer::IsInKickQueue()

  1654 {

  1655 	return m_bIsInKickQueue;

  1656 }

  1658 void CPlayer::MarkAsBeingKicked()

  1659 {

  1660 	m_bIsInKickQueue = true;

  1661 }

  1663 int CPlayer::GetLifeState()

  1664 {

  1665 	if (lifestate_offset == -1)

  1666 	{

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

  1668 		{

  1669 			lifestate_offset = -2;

  1670 		}

  1671 	}

  1673 	if (lifestate_offset < 0)

  1674 	{

  1675 		IPlayerInfo *info = GetPlayerInfo();

  1676 		if (info == NULL)

  1677 		{

  1678 			return PLAYER_LIFE_UNKNOWN;

  1679 		}

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

  1681 	}

  1683 	if (m_pEdict == NULL)

  1684 	{

  1685 		return PLAYER_LIFE_UNKNOWN;

  1686 	}

  1688 	CBaseEntity *pEntity;

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

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

  1691 	{

  1692 		return PLAYER_LIFE_UNKNOWN;

  1693 	}

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

  1696 	{

  1697 		return PLAYER_LIFE_ALIVE;

  1698 	}

  1699 	else

  1700 	{

  1701 		return PLAYER_LIFE_DEAD;

  1702 	}

  1703 }

author	David Anderson <dvander@alliedmods.net>
	Sun Oct 05 15:20:17 2008 -0700 (2008-10-05)
changeset 2342	70d4ef38b90e
parent 2323	efa6bfdd7571
child 2365	40430f687836
permissions	-rw-r--r--