sourcemod-central: core/PlayerManager.cpp@46c76edb0875

     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"

    51 PlayerManager g_Players;

    52 bool g_OnMapStarted = false;

    53 IForward *PreAdminCheck = NULL;

    54 IForward *PostAdminCheck = NULL;

    55 IForward *PostAdminFilter = NULL;

    56 IForward *OnClientConnected = NULL;

    57 const unsigned int *g_NumPlayersToAuth = NULL;

    58 int lifestate_offset = -1;

    59 List<ICommandTargetProcessor *> target_processors;

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

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

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

    64 #if defined ORANGEBOX_BUILD

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

    66 #else

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

    68 #endif

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

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

    72 #if defined ORANGEBOX_BUILD

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

    74 #else

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

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

    77 #endif

    79 ConCommand *maxplayersCmd = NULL;

    81 class KickPlayerTimer : public ITimedEvent

    82 {

    83 public:

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

    85 	{

    86 		int userid = (int)pData;

    87 		int client = g_Players.GetClientOfUserId(userid);

    88 		if (client)

    89 		{

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

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

    92 		}

    93 		return Pl_Stop;

    94 	}

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

    96 	{

    97 	}

    98 } s_KickPlayerTimer;

   100 PlayerManager::PlayerManager()

   101 {

   102 	m_AuthQueue = NULL;

   103 	m_FirstPass = false;

   104 	m_maxClients = 0;

   106 	m_UserIdLookUp = new int[USHRT_MAX+1];

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

   108 }

   110 PlayerManager::~PlayerManager()

   111 {

   112 	g_NumPlayersToAuth = NULL;

   114 	delete [] m_AuthQueue;

   115 	delete [] m_UserIdLookUp;

   116 }

   118 void PlayerManager::OnSourceModAllInitialized()

   119 {

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

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

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

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

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

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

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

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

   129 	g_ShareSys.AddInterface(NULL, this);

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

   132 	ParamType p2[] = {Param_Cell};

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

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

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

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

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

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

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

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

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

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

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

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

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

   149 	m_bIsListenServer = !engine->IsDedicatedServer();

   150 	m_ListenClient = 0;

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

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

   155 	ConCommand *pCmd = NULL;

   156 	while (pBase)

   157 	{

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

   159 		{

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

   161 			if (!pBase->IsCommand())

   162 			{

   163 				break;

   164 			}

   166 			pCmd = (ConCommand *)pBase;

   167 			break;

   168 		}

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

   170 	}

   172 	if (pCmd != NULL)

   173 	{

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

   175 		maxplayersCmd = pCmd;

   176 	}

   177 }

   179 void PlayerManager::OnSourceModShutdown()

   180 {

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

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

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

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

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

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

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

   189 	/* Release forwards */

   190 	g_Forwards.ReleaseForward(m_clconnect);

   191 	g_Forwards.ReleaseForward(m_clputinserver);

   192 	g_Forwards.ReleaseForward(m_cldisconnect);

   193 	g_Forwards.ReleaseForward(m_cldisconnect_post);

   194 	g_Forwards.ReleaseForward(m_clcommand);

   195 	g_Forwards.ReleaseForward(m_clinfochanged);

   196 	g_Forwards.ReleaseForward(m_clauth);

   197 	g_Forwards.ReleaseForward(m_onActivate);

   198 	g_Forwards.ReleaseForward(m_onActivate2);

   199 	g_Forwards.ReleaseForward(OnClientConnected);

   201 	g_Forwards.ReleaseForward(PreAdminCheck);

   202 	g_Forwards.ReleaseForward(PostAdminCheck);

   203 	g_Forwards.ReleaseForward(PostAdminFilter);

   205 	delete [] m_Players;

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

   209 	if (maxplayersCmd != NULL)

   210 	{

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

   212 	}

   213 }

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

   216 												 const char *value,

   217 												 ConfigSource source,

   218 												 char *error,

   219 												 size_t maxlength)

   220 {

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

   222 	{

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

   224 		{

   225 			m_PassInfoVar.assign(value);

   226 		}

   227 		return ConfigResult_Accept;

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

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

   230 		{

   231 			m_QueryLang = true;

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

   233 			m_QueryLang = false;

   234 		} else {

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

   236 			return ConfigResult_Reject;

   237 		}

   238 		return ConfigResult_Accept;

   239 	}

   240 	return ConfigResult_Ignore;

   241 }

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

   244 {

   245 	if (!m_FirstPass)

   246 	{

   247 		/* Initialize all players */

   248 		m_maxClients = clientMax;

   249 		m_PlayerCount = 0;

   250 		m_Players = new CPlayer[ABSOLUTE_PLAYER_LIMIT + 1];

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

   252 		m_FirstPass = true;

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

   256 		g_NumPlayersToAuth = &m_AuthQueue[0];

   258 		g_PluginSys.SyncMaxClients(clientMax);

   259 	}

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

   261 	m_onActivate->Execute(NULL);

   262 	m_onActivate2->Execute(NULL);

   264 	List<IClientListener *>::iterator iter;

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

   266 	{

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

   268 		{

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

   270 		}

   271 	}

   273 	g_OnMapStarted = true;

   275 	SMGlobalClass *cls = SMGlobalClass::head;

   276 	while (cls)

   277 	{

   278 		cls->OnSourceModLevelActivated();

   279 		cls = cls->m_pGlobalClassNext;

   280 	}

   282 	SM_ExecuteAllConfigs();

   283 }

   285 bool PlayerManager::IsServerActivated()

   286 {

   287 	return m_FirstPass;

   288 }

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

   291 {

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

   293 	if (password != NULL)

   294 	{

   295 		if (m_PassInfoVar.size() < 1)

   296 		{

   297 			return false;

   298 		}

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

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

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

   303 		{

   304 			return false;

   305 		}

   306 	}

   308 	pPlayer->SetAdminId(id, false);

   310 	return true;

   311 }

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

   314 {

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

   316 	if (password == NULL)

   317 	{

   318 		return false;

   319 	}

   321 	if (m_PassInfoVar.size() < 1)

   322 	{

   323 		return false;

   324 	}

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

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

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

   329 	{

   330 		return false;

   331 	}

   333 	pPlayer->SetAdminId(id, false);

   335 	return true;

   336 }

   338 void PlayerManager::RunAuthChecks()

   339 {

   340 	CPlayer *pPlayer;

   341 	const char *authstr;

   342 	unsigned int removed = 0;

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

   344 	{

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

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

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

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

   349 		{

   350 			/* Set authorization */

   351 			pPlayer->Authorize(authstr);

   353 			/* Mark as removed from queue */

   354 			unsigned int client = m_AuthQueue[i];

   355 			m_AuthQueue[i] = 0;

   356 			removed++;

   358 			/* Send to extensions */

   359 			List<IClientListener *>::iterator iter;

   360 			IClientListener *pListener;

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

   362 			{

   363 				pListener = (*iter);

   364 				pListener->OnClientAuthorized(client, authstr);

   365 				if (!pPlayer->IsConnected())

   366 				{

   367 					break;

   368 				}

   369 			}

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

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

   373 			{

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

   375 				m_clauth->PushCell(client);

   376 				m_clauth->PushString(authstr);

   377 				m_clauth->Execute(NULL);

   378 			}

   380 			if (pPlayer->IsConnected())

   381 			{

   382 				pPlayer->Authorize_Post();

   383 			}

   384 		}

   385 	}

   387 	/* Clean up the queue */

   388 	if (removed)

   389 	{

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

   391 		if (removed != m_AuthQueue[0])

   392 		{

   393 			unsigned int diff = 0;

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

   395 			{

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

   397 				if (m_AuthQueue[i] == 0)

   398 				{

   399 					/* Increase the differential */

   400 					diff++;

   401 				} else {

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

   403 					assert(i > diff);

   404 					assert(i - diff >= 1);

   405 					/* move this index down */

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

   407 				}

   408 			}

   409 			m_AuthQueue[0] -= removed;

   410 		} else {

   411 			m_AuthQueue[0] = 0;

   412 		}

   413 	}

   414 }

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

   417 {

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

   419 	CPlayer *pPlayer = &m_Players[client];

   421 	List<IClientListener *>::iterator iter;

   422 	IClientListener *pListener = NULL;

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

   424 	{

   425 		pListener = (*iter);

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

   427 		{

   428 			return false;

   429 		}

   430 	}

   432 	cell_t res = 1;

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

   435 	m_clconnect->PushCell(client);

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

   437 	m_clconnect->PushCell(maxrejectlen);

   438 	m_clconnect->Execute(&res);

   440 	if (res)

   441 	{

   442 		if (!pPlayer->IsAuthorized())

   443 		{

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

   445 		}

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

   448 	}

   449 	else

   450 	{

   451 		if (!pPlayer->IsFakeClient())

   452 		{

   453 			RETURN_META_VALUE(MRES_SUPERCEDE, false);

   454 		}

   455 	}

   457 	return true;

   458 }

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

   461 {

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

   463 	bool orig_value = META_RESULT_ORIG_RET(bool);

   464 	CPlayer *pPlayer = &m_Players[client];

   466 	if (orig_value)

   467 	{

   468 		List<IClientListener *>::iterator iter;

   469 		IClientListener *pListener = NULL;

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

   471 		{

   472 			pListener = (*iter);

   473 			pListener->OnClientConnected(client);

   474 			if (!pPlayer->IsConnected())

   475 			{

   476 				break;

   477 			}

   478 		}

   480 		if (!pPlayer->IsFakeClient()

   481 			&& m_bIsListenServer

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

   483 		{

   484 			m_ListenClient = client;

   485 		}

   487 		cell_t res;

   488 		OnClientConnected->PushCell(client);

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

   490 	}

   491 	else

   492 	{

   493 		InvalidatePlayer(pPlayer);

   494 	}

   496 	return true;

   497 }

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

   500 {

   501 	cell_t res;

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

   503 	CPlayer *pPlayer = &m_Players[client];

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

   506 	if (!pPlayer->IsConnected())

   507 	{

   508 		/* Run manual connection routines */

   509 		char error[255];

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

   511 		pPlayer->Authorize(authid);

   512 		pPlayer->m_bFakeClient = true;

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

   514 		{

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

   516 			return;

   517 		}

   518 		List<IClientListener *>::iterator iter;

   519 		IClientListener *pListener = NULL;

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

   521 		{

   522 			pListener = (*iter);

   523 			pListener->OnClientConnected(client);

   524 			/* See if bot was kicked */

   525 			if (!pPlayer->IsConnected())

   526 			{

   527 				return;

   528 			}

   529 		}

   530 		/* Now do authorization */

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

   532 		{

   533 			pListener = (*iter);

   534 			pListener->OnClientAuthorized(client, authid);

   535 		}

   536 		/* Finally, tell plugins */

   537 		if (m_clauth->GetFunctionCount())

   538 		{

   539 			m_clauth->PushCell(client);

   540 			m_clauth->PushString(authid);

   541 			m_clauth->Execute(NULL);

   542 		}

   543 		pPlayer->Authorize_Post();

   544 	}

   546 	if (playerinfo)

   547 	{

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

   549 	}

   551 	/* Get the client's language */

   552 	if (m_QueryLang)

   553 	{

   554 		const char *name;

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

   556 		{

   557 			unsigned int langid;

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

   559 		} else {

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

   561 		}

   562 	}

   564 	pPlayer->Connect();

   565 	m_PlayerCount++;

   567 	List<IClientListener *>::iterator iter;

   568 	IClientListener *pListener = NULL;

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

   570 	{

   571 		pListener = (*iter);

   572 		pListener->OnClientPutInServer(client);

   573 	}

   575 	m_clputinserver->PushCell(client);

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

   578 	if (pPlayer->IsAuthorized())

   579 	{

   580 		pPlayer->DoPostConnectAuthorization();

   581 	}

   582 }

   584 void PlayerManager::OnSourceModLevelEnd()

   585 {

   586 	/* Disconnect all bots still in game */

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

   588 	{

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

   590 		{

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

   592 		}

   593 	}

   594 	m_PlayerCount = 0;

   595 }

   597 void PlayerManager::OnClientDisconnect(edict_t *pEntity)

   598 {

   599 	cell_t res;

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

   601 	CPlayer *pPlayer = &m_Players[client];

   603 	if (pPlayer->IsConnected())

   604 	{

   605 		m_cldisconnect->PushCell(client);

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

   607 	}

   608 	else

   609 	{

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

   611 		return;

   612 	}

   614 	if (pPlayer->WasCountedAsInGame())

   615 	{

   616 		m_PlayerCount--;

   617 	}

   619 	List<IClientListener *>::iterator iter;

   620 	IClientListener *pListener = NULL;

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

   622 	{

   623 		pListener = (*iter);

   624 		pListener->OnClientDisconnecting(client);

   625 	}

   627 	InvalidatePlayer(pPlayer);

   629 	if (m_ListenClient == client)

   630 	{

   631 		m_ListenClient = 0;

   632 	}

   633 }

   635 void PlayerManager::OnClientDisconnect_Post(edict_t *pEntity)

   636 {

   637 	cell_t res;

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

   640 	m_cldisconnect_post->PushCell(client);

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

   643 	List<IClientListener *>::iterator iter;

   644 	IClientListener *pListener = NULL;

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

   646 	{

   647 		pListener = (*iter);

   648 		pListener->OnClientDisconnected(client);

   649 	}

   650 }

   652 #if defined ORANGEBOX_BUILD

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

   654 {

   655 #else

   656 void PlayerManager::OnClientCommand(edict_t *pEntity)

   657 {

   658 	CCommand args;

   659 #endif

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

   661 	cell_t res = Pl_Continue;

   662 	CPlayer *pPlayer = &m_Players[client];

   664 	if (!pPlayer->IsConnected())

   665 	{

   666 		return;

   667 	}

   669 	g_HL2.PushCommandStack(&args);

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

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

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

   675 	if (result)

   676 	{

   677 		res = Pl_Handled;

   678 	} else {

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

   680 		if (result)

   681 		{

   682 			res = Pl_Handled;

   683 		}

   684 	}

   686 	cell_t res2 = Pl_Continue;

   687 	m_clcommand->PushCell(client);

   688 	m_clcommand->PushCell(argcount);

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

   691 	if (res2 > res)

   692 	{

   693 		res = res2;

   694 	}

   696 	if (res >= Pl_Stop)

   697 	{

   698 		g_HL2.PopCommandStack();

   699 		RETURN_META(MRES_SUPERCEDE);

   700 	}

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

   704 	g_HL2.PopCommandStack();

   706 	if (res >= Pl_Handled)

   707 	{

   708 		RETURN_META(MRES_SUPERCEDE);

   709 	}

   710 }

   712 void PlayerManager::OnClientSettingsChanged(edict_t *pEntity)

   713 {

   714 	cell_t res;

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

   716 	CPlayer *pPlayer = &m_Players[client];

   718 	if (!pPlayer->IsConnected())

   719 	{

   720 		return;

   721 	}

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

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

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

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

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

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

   731 	{

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

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

   734 		{

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

   736 			{

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

   738 				RETURN_META(MRES_IGNORED);

   739 			}

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

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

   742 			{

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

   744 				pPlayer->SetAdminId(INVALID_ADMIN_ID, false);

   745 			}

   746 		}

   747 		pPlayer->SetName(new_name);

   748 	}

   750 	if (m_PassInfoVar.size() > 0)

   751 	{

   752 		/* Try for a password change */

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

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

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

   756 		{

   757 			pPlayer->m_LastPassword.assign(new_pass);

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

   759 			{

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

   761 				pPlayer->DoBasicAdminChecks();

   762 			}

   763 		}

   764 	}

   765 }

   767 int PlayerManager::GetMaxClients()

   768 {

   769 	return m_maxClients;

   770 }

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

   773 {

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

   775 	{

   776 		return NULL;

   777 	}

   778 	return &m_Players[client];

   779 }

   781 int PlayerManager::GetNumPlayers()

   782 {

   783 	return m_PlayerCount;

   784 }

   786 int PlayerManager::GetClientOfUserId(int userid)

   787 {

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

   789 	{

   790 		return 0;

   791 	}

   793 	int client = m_UserIdLookUp[userid];

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

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

   797 	 * check before invoking this backwards compat code.

   798 	 */

   799 	if (client)

   800 	{

   801 		CPlayer *player = GetPlayerByIndex(client);

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

   803 		{

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

   805 			if (realUserId == userid)

   806 			{

   807 				return client;

   808 			}

   809 		}

   810 	}

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

   813 	CPlayer *player;

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

   815 	{

   816 		player = GetPlayerByIndex(i);

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

   818 		{

   819 			continue;

   820 		}

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

   822 		{

   823 			m_UserIdLookUp[userid] = i;

   824 			return i;

   825 		}

   826 	}

   828 	return 0;

   829 }

   831 void PlayerManager::AddClientListener(IClientListener *listener)

   832 {

   833 	m_hooks.push_back(listener);

   834 }

   836 void PlayerManager::RemoveClientListener(IClientListener *listener)

   837 {

   838 	m_hooks.remove(listener);

   839 }

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

   842 {

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

   844 	return GetGamePlayer(index);

   845 }

   847 IGamePlayer *PlayerManager::GetGamePlayer(int client)

   848 {

   849 	return GetPlayerByIndex(client);

   850 }

   852 void PlayerManager::ClearAdminId(AdminId id)

   853 {

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

   855 	{

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

   857 		{

   858 			m_Players[i].DumpAdmin(true);

   859 		}

   860 	}

   861 }

   863 void PlayerManager::ClearAllAdmins()

   864 {

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

   866 	{

   867 		m_Players[i].DumpAdmin(true);

   868 	}

   869 }

   871 const char *PlayerManager::GetPassInfoVar()

   872 {

   873 	return m_PassInfoVar.c_str();

   874 }

   876 void PlayerManager::RecheckAnyAdmins()

   877 {

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

   879 	{

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

   881 		{

   882 			m_Players[i].DoBasicAdminChecks();

   883 		}

   884 	}

   885 }

   887 unsigned int PlayerManager::GetReplyTo()

   888 {

   889 	return g_ChatTriggers.GetReplyTo();

   890 }

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

   893 {

   894 	return g_ChatTriggers.SetReplyTo(reply);

   895 }

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

   898 {

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

   900 }

   902 void PlayerManager::RegisterCommandTargetProcessor(ICommandTargetProcessor *pHandler)

   903 {

   904 	target_processors.push_back(pHandler);

   905 }

   907 void PlayerManager::UnregisterCommandTargetProcessor(ICommandTargetProcessor *pHandler)

   908 {

   909 	target_processors.remove(pHandler);

   910 }

   912 void PlayerManager::InvalidatePlayer(CPlayer *pPlayer)

   913 {

   914 	/**

   915 	* Remove client from auth queue if necessary

   916 	*/

   917 	if (!pPlayer->IsAuthorized())

   918 	{

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

   920 		{

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

   922 			{

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

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

   925 				{

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

   927 				}

   928 				/* Remove us and break */

   929 				m_AuthQueue[0]--;

   930 				break;

   931 			}

   932 		}

   933 	}

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

   936 	pPlayer->Disconnect();

   937 }

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

   940 {

   941 	if ((flags & COMMAND_FILTER_CONNECTED) == COMMAND_FILTER_CONNECTED

   942 		&& !pTarget->IsConnected())

   943 	{

   944 		return COMMAND_TARGET_NONE;

   945 	}

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

   947 		!pTarget->IsInGame())

   948 	{

   949 		return COMMAND_TARGET_NOT_IN_GAME;

   950 	}

   952 	if ((flags & COMMAND_FILTER_NO_BOTS) == COMMAND_FILTER_NO_BOTS

   953 		&& pTarget->IsFakeClient())

   954 	{

   955 		return COMMAND_TARGET_NOT_HUMAN;

   956 	}

   958 	if (pAdmin != NULL)

   959 	{

   960 		if ((flags & COMMAND_FILTER_NO_IMMUNITY) != COMMAND_FILTER_NO_IMMUNITY

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

   962 		{

   963 			return COMMAND_TARGET_IMMUNE;

   964 		}

   965 	}

   967 	if ((flags & COMMAND_FILTER_ALIVE) == COMMAND_FILTER_ALIVE

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

   969 	{

   970 		return COMMAND_TARGET_NOT_ALIVE;

   971 	}

   973 	if ((flags & COMMAND_FILTER_DEAD) == COMMAND_FILTER_DEAD

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

   975 	{

   976 		return COMMAND_TARGET_NOT_DEAD;

   977 	}

   979 	return COMMAND_TARGET_VALID;

   980 }

   982 void PlayerManager::ProcessCommandTarget(cmd_target_info_t *info)

   983 {

   984 	CPlayer *pTarget, *pAdmin;

   985 	int max_clients, total = 0;

   987 	max_clients = GetMaxClients();

   989 	if (info->max_targets < 1)

   990 	{

   991 		info->reason = COMMAND_TARGET_NONE;

   992 		info->num_targets = 0;

   993 	}

   995 	if (info->admin == 0)

   996 	{

   997 		pAdmin = NULL;

   998 	}

   999 	else

  1000 	{

  1001 		pAdmin = GetPlayerByIndex(info->admin);

  1002 	}

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

  1005 	{

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

  1007 		int client = GetClientOfUserId(userid);

  1009 		/* See if a valid userid matched */

  1010 		if (client > 0)

  1011 		{

  1012 			IGamePlayer *pTarget = GetPlayerByIndex(client);

  1013 			if (pTarget != NULL)

  1014 			{

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

  1016 				{

  1017 					info->targets[0] = client;

  1018 					info->num_targets = 1;

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

  1020 					info->target_name_style = COMMAND_TARGETNAME_RAW;

  1021 				}

  1022 				else

  1023 				{

  1024 					info->num_targets = 0;

  1025 				}

  1026 				return;

  1027 			}

  1028 		}

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

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

  1032 		{

  1033 			size_t p, len;

  1034 			char new_pattern[256];

  1036 			strcpy(new_pattern, "STEAM_");

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

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

  1039 			{

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

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

  1042 				{

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

  1044 				}

  1045 			}

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

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

  1049 			{

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

  1051 				{

  1052 					continue;

  1053 				}

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

  1055 				{

  1056 					continue;

  1057 				}

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

  1059 				{

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

  1061 						== COMMAND_TARGET_VALID)

  1062 					{

  1063 						info->targets[0] = i;

  1064 						info->num_targets = 1;

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

  1066 						info->target_name_style = COMMAND_TARGETNAME_RAW;

  1067 					}

  1068 					else

  1069 					{

  1070 						info->num_targets = 0;

  1071 					}

  1072 					return;

  1073 				}

  1074 			}

  1075 		}

  1077 		/* See if an exact name matches */

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

  1079 		{

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

  1081 			{

  1082 				continue;

  1083 			}

  1084 			if  (!pTarget->IsConnected())

  1085 			{

  1086 				continue;

  1087 			}

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

  1089 			{

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

  1091 					== COMMAND_TARGET_VALID)

  1092 				{

  1093 					info->targets[0] = i;

  1094 					info->num_targets = 1;

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

  1096 					info->target_name_style = COMMAND_TARGETNAME_RAW;

  1097 				}

  1098 				else

  1099 				{

  1100 					info->num_targets = 0;

  1101 				}

  1102 				return;

  1103 			}

  1104 		}

  1105 	}

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

  1108 	{

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

  1110 		info->num_targets = 1;

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

  1112 		info->target_name_style = COMMAND_TARGETNAME_RAW;

  1113 		return;

  1114 	}

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

  1117 	{

  1118 		bool is_multi = false;

  1119 		bool bots_only = false;

  1120 		int skip_client = -1;

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

  1123 		{

  1124 			is_multi = true;

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

  1126 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1127 		}

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

  1129 		{

  1130 			is_multi = true;

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

  1132 			{

  1133 				info->num_targets = 0;

  1134 				info->reason = COMMAND_TARGET_NOT_ALIVE;

  1135 				return;

  1136 			}

  1137 			info->flags |= COMMAND_FILTER_DEAD;

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

  1139 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1140 		}

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

  1142 		{

  1143 			is_multi = true;

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

  1145 			{

  1146 				info->num_targets = 0;

  1147 				info->reason = COMMAND_TARGET_NOT_DEAD;

  1148 				return;

  1149 			}

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

  1151 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1152 			info->flags |= COMMAND_FILTER_ALIVE;

  1153 		}

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

  1155 		{

  1156 			is_multi = true;

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

  1158 			{

  1159 				info->num_targets = 0;

  1160 				info->reason = COMMAND_FILTER_NO_BOTS;

  1161 				return;

  1162 			}

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

  1164 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1165 			bots_only = true;

  1166 		}

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

  1168 		{

  1169 			is_multi = true;

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

  1171 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1172 			info->flags |= COMMAND_FILTER_NO_BOTS;

  1173 		}

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

  1175 		{

  1176 			is_multi = true;

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

  1178 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1179 			skip_client = info->admin;

  1180 		}

  1182 		if (is_multi)

  1183 		{

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

  1185 			{

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

  1187 				{

  1188 					continue;

  1189 				}

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

  1191 				{

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

  1193 						&& skip_client != i)

  1194 					{

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

  1196 					}

  1197 				}

  1198 			}

  1200 			info->num_targets = total;

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

  1202 			return;

  1203 		}

  1204 	}

  1206 	List<ICommandTargetProcessor *>::iterator iter;

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

  1208 	{

  1209 		ICommandTargetProcessor *pProcessor = (*iter);

  1210 		if (pProcessor->ProcessCommandTarget(info))

  1211 		{

  1212 			return;

  1213 		}

  1214 	}

  1216 	/* Check partial names */

  1217 	int found_client = 0;

  1218 	CPlayer *pFoundClient = NULL;

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

  1220 	{

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

  1222 		{

  1223 			continue;

  1224 		}

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

  1227 		{

  1228 			if (found_client)

  1229 			{

  1230 				info->num_targets = 0;

  1231 				info->reason = COMMAND_TARGET_AMBIGUOUS;

  1232 				return;

  1233 			}

  1234 			else

  1235 			{

  1236 				found_client = i;

  1237 				pFoundClient = pTarget;

  1238 			}

  1239 		}

  1240 	}

  1242 	if (found_client)

  1243 	{

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

  1245 			== COMMAND_TARGET_VALID)

  1246 		{

  1247 			info->targets[0] = found_client;

  1248 			info->num_targets = 1;

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

  1250 			info->target_name_style = COMMAND_TARGETNAME_RAW;

  1251 		}

  1252 		else

  1253 		{

  1254 			info->num_targets = 0;

  1255 		}

  1256 	}

  1257 	else

  1258 	{

  1259 		info->num_targets = 0;

  1260 		info->reason = COMMAND_TARGET_NONE;

  1261 	}

  1262 }

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

  1265 {

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

  1267 	{

  1268 		MaxPlayersChanged(gpGlobals->maxClients + 1);

  1269 	}

  1270 	else

  1271 	{

  1272 		MaxPlayersChanged();

  1273 	}

  1274 }

  1276 void PlayerManager::OnSourceModMaxPlayersChanged( int newvalue )

  1277 {

  1278 	m_maxClients = newvalue;

  1279 }

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

  1282 {

  1283 	if (newvalue == -1)

  1284 	{

  1285 		newvalue = gpGlobals->maxClients;

  1286 	}

  1288 	if (newvalue == MaxClients())

  1289 	{

  1290 		return;

  1291 	}

  1293 	/* Notify the rest of core */

  1294 	SMGlobalClass *pBase = SMGlobalClass::head;

  1295 	while (pBase)

  1296 	{

  1297 		pBase->OnSourceModMaxPlayersChanged(newvalue);

  1298 		pBase = pBase->m_pGlobalClassNext;

  1299 	}

  1301 	/* Notify Extensions */

  1302 	List<IClientListener *>::iterator iter;

  1303 	IClientListener *pListener = NULL;

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

  1305 	{

  1306 		pListener = (*iter);

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

  1308 		{

  1309 			pListener->OnMaxPlayersChanged(newvalue);

  1310 		}

  1311 	}

  1312 }

  1314 #if defined ORANGEBOX_BUILD

  1315 void CmdMaxplayersCallback(const CCommand &command)

  1316 {

  1317 #else

  1318 void CmdMaxplayersCallback()

  1319 {

  1320 #endif

  1322 	g_Players.MaxPlayersChanged();

  1323 }

  1326 /*******************

  1327  *** PLAYER CODE ***

  1328  *******************/

  1330 CPlayer::CPlayer()

  1331 {

  1332 	m_IsConnected = false;

  1333 	m_IsInGame = false;

  1334 	m_IsAuthorized = false;

  1335 	m_pEdict = NULL;

  1336 	m_Admin = INVALID_ADMIN_ID;

  1337 	m_TempAdmin = false;

  1338 	m_Info = NULL;

  1339 	m_bAdminCheckSignalled = false;

  1340 	m_bIsInKickQueue = false;

  1341 	m_LastPassword.clear();

  1342 	m_LangId = SOURCEMOD_LANGUAGE_ENGLISH;

  1343 	m_bFakeClient = false;

  1344 }

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

  1347 {

  1348 	m_IsConnected = true;

  1349 	m_Name.assign(name);

  1350 	m_Ip.assign(ip);

  1351 	m_pEdict = pEntity;

  1352 	m_iIndex = engine->IndexOfEdict(pEntity);

  1353 	m_LangId = g_Translator.GetServerLanguage();

  1355 	char ip2[24], *ptr;

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

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

  1358 	{

  1359 		*ptr = '\0';

  1360 	}

  1361 	m_IpNoPort.assign(ip2);

  1362 }

  1364 void CPlayer::Connect()

  1365 {

  1366 	if (m_IsInGame)

  1367 	{

  1368 		return;

  1369 	}

  1371 	m_IsInGame = true;

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

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

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

  1376 	{

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

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

  1379 	}

  1380 	else

  1381 	{

  1382 		m_LastPassword.assign("");

  1383 	}

  1384 }

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

  1387 {

  1388 	if (m_IsAuthorized)

  1389 	{

  1390 		return;

  1391 	}

  1393 	m_IsAuthorized = true;

  1394 	m_AuthID.assign(steamid);

  1395 }

  1397 void CPlayer::Disconnect()

  1398 {

  1399 	DumpAdmin(false);

  1400 	m_IsConnected = false;

  1401 	m_IsInGame = false;

  1402 	m_IsAuthorized = false;

  1403 	m_Name.clear();

  1404 	m_Ip.clear();

  1405 	m_AuthID.clear();

  1406 	m_pEdict = NULL;

  1407 	m_Info = NULL;

  1408 	m_bAdminCheckSignalled = false;

  1409 	m_UserId = -1;

  1410 	m_bIsInKickQueue = false;

  1411 	m_bFakeClient = false;

  1412 }

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

  1415 {

  1416 	m_Name.assign(name);

  1417 }

  1419 const char *CPlayer::GetName()

  1420 {

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

  1422 	{

  1423 		return m_Info->GetName();

  1424 	}

  1426 	return m_Name.c_str();

  1427 }

  1429 const char *CPlayer::GetIPAddress()

  1430 {

  1431 	return m_Ip.c_str();

  1432 }

  1434 const char *CPlayer::GetAuthString()

  1435 {

  1436 	return m_AuthID.c_str();

  1437 }

  1439 edict_t *CPlayer::GetEdict()

  1440 {

  1441 	return m_pEdict;

  1442 }

  1444 bool CPlayer::IsInGame()

  1445 {

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

  1447 }

  1449 bool CPlayer::WasCountedAsInGame()

  1450 {

  1451 	return m_IsInGame;

  1452 }

  1454 bool CPlayer::IsConnected()

  1455 {

  1456 	return m_IsConnected;

  1457 }

  1459 bool CPlayer::IsAuthorized()

  1460 {

  1461 	return m_IsAuthorized;

  1462 }

  1464 IPlayerInfo *CPlayer::GetPlayerInfo()

  1465 {

  1466 	if (m_pEdict->GetUnknown())

  1467 	{

  1468 		return m_Info;

  1469 	}

  1471 	return NULL;

  1472 }

  1474 bool CPlayer::IsFakeClient()

  1475 {

  1476 	return m_bFakeClient;

  1477 }

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

  1480 {

  1481 	if (!m_IsConnected)

  1482 	{

  1483 		return;

  1484 	}

  1486 	DumpAdmin(false);

  1488 	m_Admin = id;

  1489 	m_TempAdmin = temporary;

  1490 }

  1492 AdminId CPlayer::GetAdminId()

  1493 {

  1494 	return m_Admin;

  1495 }

  1497 void CPlayer::DumpAdmin(bool deleting)

  1498 {

  1499 	if (m_Admin != INVALID_ADMIN_ID)

  1500 	{

  1501 		if (m_TempAdmin && !deleting)

  1502 		{

  1503 			g_Admins.InvalidateAdmin(m_Admin);

  1504 		}

  1505 		m_Admin = INVALID_ADMIN_ID;

  1506 		m_TempAdmin = false;

  1507 	}

  1508 }

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

  1511 {

  1512 	MarkAsBeingKicked();

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

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

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

  1516 }

  1518 void CPlayer::Authorize_Post()

  1519 {

  1520 	if (m_IsInGame)

  1521 	{

  1522 		DoPostConnectAuthorization();

  1523 	}

  1524 }

  1526 void CPlayer::DoPostConnectAuthorization()

  1527 {

  1528 	bool delay = false;

  1530 	List<IClientListener *>::iterator iter;

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

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

  1533 		 iter++)

  1534 	{

  1535 		IClientListener *pListener = (*iter);

  1536 #if defined MIN_API_FOR_ADMINCALLS

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

  1538 		{

  1539 			continue;

  1540 		}

  1541 #endif

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

  1543 		{

  1544 			delay = true;

  1545 		}

  1546 	}

  1548 	cell_t result = 0;

  1549 	PreAdminCheck->PushCell(m_iIndex);

  1550 	PreAdminCheck->Execute(&result);

  1552 	/* Defer, for better or worse */

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

  1554 	{

  1555 		return;

  1556 	}

  1558 	/* Sanity check */

  1559 	if (!IsConnected())

  1560 	{

  1561 		return;

  1562 	}

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

  1565 	DoBasicAdminChecks();

  1567 	/* Send the notification out */

  1568 	NotifyPostAdminChecks();

  1569 }

  1571 bool CPlayer::RunAdminCacheChecks()

  1572 {

  1573 	AdminId old_id = GetAdminId();

  1575 	DoBasicAdminChecks();

  1577 	return (GetAdminId() != old_id);

  1578 }

  1580 void CPlayer::NotifyPostAdminChecks()

  1581 {

  1582 	if (m_bAdminCheckSignalled)

  1583 	{

  1584 		return;

  1585 	}

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

  1588 	m_bAdminCheckSignalled = true;

  1590 	List<IClientListener *>::iterator iter;

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

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

  1593 		iter++)

  1594 	{

  1595 		IClientListener *pListener = (*iter);

  1596 #if defined MIN_API_FOR_ADMINCALLS

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

  1598 		{

  1599 			continue;

  1600 		}

  1601 #endif

  1602 		pListener->OnClientPostAdminCheck(m_iIndex);

  1603 	}

  1605 	PostAdminFilter->PushCell(m_iIndex);

  1606 	PostAdminFilter->Execute(NULL);

  1608 	PostAdminCheck->PushCell(m_iIndex);

  1609 	PostAdminCheck->Execute(NULL);

  1610 }

  1612 void CPlayer::DoBasicAdminChecks()

  1613 {

  1614 	if (GetAdminId() != INVALID_ADMIN_ID)

  1615 	{

  1616 		return;

  1617 	}

  1619 	/* First check the name */

  1620 	AdminId id;

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

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

  1624 	{

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

  1626 		{

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

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

  1629 		}

  1630 		return;

  1631 	}

  1633 	/* Check IP */

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

  1635 	{

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

  1637 		{

  1638 			return;

  1639 		}

  1640 	}

  1642 	/* Check steam id */

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

  1644 	{

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

  1646 		{

  1647 			return;

  1648 		}

  1649 	}

  1650 }

  1652 unsigned int CPlayer::GetLanguageId()

  1653 {

  1654 	return m_LangId;

  1655 }

  1657 int CPlayer::GetUserId()

  1658 {

  1659 	if (m_UserId == -1)

  1660 	{

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

  1662 	}

  1664 	return m_UserId;

  1665 }

  1667 bool CPlayer::IsInKickQueue()

  1668 {

  1669 	return m_bIsInKickQueue;

  1670 }

  1672 void CPlayer::MarkAsBeingKicked()

  1673 {

  1674 	m_bIsInKickQueue = true;

  1675 }

  1677 int CPlayer::GetLifeState()

  1678 {

  1679 	if (lifestate_offset == -1)

  1680 	{

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

  1682 		{

  1683 			lifestate_offset = -2;

  1684 		}

  1685 	}

  1687 	if (lifestate_offset < 0)

  1688 	{

  1689 		IPlayerInfo *info = GetPlayerInfo();

  1690 		if (info == NULL)

  1691 		{

  1692 			return PLAYER_LIFE_UNKNOWN;

  1693 		}

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

  1695 	}

  1697 	if (m_pEdict == NULL)

  1698 	{

  1699 		return PLAYER_LIFE_UNKNOWN;

  1700 	}

  1702 	CBaseEntity *pEntity;

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

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

  1705 	{

  1706 		return PLAYER_LIFE_UNKNOWN;

  1707 	}

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

  1710 	{

  1711 		return PLAYER_LIFE_ALIVE;

  1712 	}

  1713 	else

  1714 	{

  1715 		return PLAYER_LIFE_DEAD;

  1716 	}

  1717 }

author	David Anderson <dvander@alliedmods.net>
	Wed Feb 25 20:25:20 2009 -0500 (2009-02-25)
changeset 2613	46c76edb0875
parent 2476	c21fd6e89ff5
child 2479	44e8e76d4e53
permissions	-rw-r--r--