sourcemod-central: core/PlayerManager.cpp@3a64d2bc51c1

     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 SOURCE_ENGINE >= SE_ORANGEBOX

    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 SOURCE_ENGINE >= SE_ORANGEBOX

    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 	ConCommand *pCmd = FindCommand("maxplayers");

   155 	if (pCmd != NULL)

   156 	{

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

   158 		maxplayersCmd = pCmd;

   159 	}

   160 }

   162 void PlayerManager::OnSourceModShutdown()

   163 {

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

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

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

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

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

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

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

   172 	/* Release forwards */

   173 	g_Forwards.ReleaseForward(m_clconnect);

   174 	g_Forwards.ReleaseForward(m_clputinserver);

   175 	g_Forwards.ReleaseForward(m_cldisconnect);

   176 	g_Forwards.ReleaseForward(m_cldisconnect_post);

   177 	g_Forwards.ReleaseForward(m_clcommand);

   178 	g_Forwards.ReleaseForward(m_clinfochanged);

   179 	g_Forwards.ReleaseForward(m_clauth);

   180 	g_Forwards.ReleaseForward(m_onActivate);

   181 	g_Forwards.ReleaseForward(m_onActivate2);

   182 	g_Forwards.ReleaseForward(OnClientConnected);

   184 	g_Forwards.ReleaseForward(PreAdminCheck);

   185 	g_Forwards.ReleaseForward(PostAdminCheck);

   186 	g_Forwards.ReleaseForward(PostAdminFilter);

   188 	delete [] m_Players;

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

   192 	if (maxplayersCmd != NULL)

   193 	{

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

   195 	}

   196 }

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

   199 												 const char *value,

   200 												 ConfigSource source,

   201 												 char *error,

   202 												 size_t maxlength)

   203 {

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

   205 	{

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

   207 		{

   208 			m_PassInfoVar.assign(value);

   209 		}

   210 		return ConfigResult_Accept;

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

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

   213 		{

   214 			m_QueryLang = true;

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

   216 			m_QueryLang = false;

   217 		} else {

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

   219 			return ConfigResult_Reject;

   220 		}

   221 		return ConfigResult_Accept;

   222 	}

   223 	return ConfigResult_Ignore;

   224 }

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

   227 {

   228 	if (!m_FirstPass)

   229 	{

   230 		/* Initialize all players */

   231 		m_maxClients = clientMax;

   232 		m_PlayerCount = 0;

   233 		m_Players = new CPlayer[ABSOLUTE_PLAYER_LIMIT + 1];

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

   235 		m_FirstPass = true;

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

   239 		g_NumPlayersToAuth = &m_AuthQueue[0];

   241 		g_PluginSys.SyncMaxClients(clientMax);

   242 	}

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

   244 	m_onActivate->Execute(NULL);

   245 	m_onActivate2->Execute(NULL);

   247 	List<IClientListener *>::iterator iter;

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

   249 	{

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

   251 		{

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

   253 		}

   254 	}

   256 	g_OnMapStarted = true;

   258 	SM_ExecuteAllConfigs();

   259 }

   261 bool PlayerManager::IsServerActivated()

   262 {

   263 	return m_FirstPass;

   264 }

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

   267 {

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

   269 	if (password != NULL)

   270 	{

   271 		if (m_PassInfoVar.size() < 1)

   272 		{

   273 			return false;

   274 		}

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

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

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

   279 		{

   280 			return false;

   281 		}

   282 	}

   284 	pPlayer->SetAdminId(id, false);

   286 	return true;

   287 }

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

   290 {

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

   292 	if (password == NULL)

   293 	{

   294 		return false;

   295 	}

   297 	if (m_PassInfoVar.size() < 1)

   298 	{

   299 		return false;

   300 	}

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

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

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

   305 	{

   306 		return false;

   307 	}

   309 	pPlayer->SetAdminId(id, false);

   311 	return true;

   312 }

   314 void PlayerManager::RunAuthChecks()

   315 {

   316 	CPlayer *pPlayer;

   317 	const char *authstr;

   318 	unsigned int removed = 0;

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

   320 	{

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

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

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

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

   325 		{

   326 			/* Set authorization */

   327 			pPlayer->Authorize(authstr);

   329 			/* Mark as removed from queue */

   330 			unsigned int client = m_AuthQueue[i];

   331 			m_AuthQueue[i] = 0;

   332 			removed++;

   334 			/* Send to extensions */

   335 			List<IClientListener *>::iterator iter;

   336 			IClientListener *pListener;

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

   338 			{

   339 				pListener = (*iter);

   340 				pListener->OnClientAuthorized(client, authstr);

   341 				if (!pPlayer->IsConnected())

   342 				{

   343 					break;

   344 				}

   345 			}

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

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

   349 			{

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

   351 				m_clauth->PushCell(client);

   352 				m_clauth->PushString(authstr);

   353 				m_clauth->Execute(NULL);

   354 			}

   356 			if (pPlayer->IsConnected())

   357 			{

   358 				pPlayer->Authorize_Post();

   359 			}

   360 		}

   361 	}

   363 	/* Clean up the queue */

   364 	if (removed)

   365 	{

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

   367 		if (removed != m_AuthQueue[0])

   368 		{

   369 			unsigned int diff = 0;

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

   371 			{

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

   373 				if (m_AuthQueue[i] == 0)

   374 				{

   375 					/* Increase the differential */

   376 					diff++;

   377 				} else {

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

   379 					assert(i > diff);

   380 					assert(i - diff >= 1);

   381 					/* move this index down */

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

   383 				}

   384 			}

   385 			m_AuthQueue[0] -= removed;

   386 		} else {

   387 			m_AuthQueue[0] = 0;

   388 		}

   389 	}

   390 }

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

   393 {

   394 	int client = IndexOfEdict(pEntity);

   395 	CPlayer *pPlayer = &m_Players[client];

   397 	List<IClientListener *>::iterator iter;

   398 	IClientListener *pListener = NULL;

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

   400 	{

   401 		pListener = (*iter);

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

   403 		{

   404 			return false;

   405 		}

   406 	}

   408 	cell_t res = 1;

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

   411 	m_clconnect->PushCell(client);

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

   413 	m_clconnect->PushCell(maxrejectlen);

   414 	m_clconnect->Execute(&res);

   416 	if (res)

   417 	{

   418 		if (!pPlayer->IsAuthorized())

   419 		{

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

   421 		}

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

   424 	}

   425 	else

   426 	{

   427 		if (!pPlayer->IsFakeClient())

   428 		{

   429 			RETURN_META_VALUE(MRES_SUPERCEDE, false);

   430 		}

   431 	}

   433 	return true;

   434 }

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

   437 {

   438 	int client = IndexOfEdict(pEntity);

   439 	bool orig_value = META_RESULT_ORIG_RET(bool);

   440 	CPlayer *pPlayer = &m_Players[client];

   442 	if (orig_value)

   443 	{

   444 		List<IClientListener *>::iterator iter;

   445 		IClientListener *pListener = NULL;

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

   447 		{

   448 			pListener = (*iter);

   449 			pListener->OnClientConnected(client);

   450 			if (!pPlayer->IsConnected())

   451 			{

   452 				break;

   453 			}

   454 		}

   456 		if (!pPlayer->IsFakeClient()

   457 			&& m_bIsListenServer

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

   459 		{

   460 			m_ListenClient = client;

   461 		}

   463 		cell_t res;

   464 		OnClientConnected->PushCell(client);

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

   466 	}

   467 	else

   468 	{

   469 		InvalidatePlayer(pPlayer);

   470 	}

   472 	return true;

   473 }

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

   476 {

   477 	cell_t res;

   478 	int client = IndexOfEdict(pEntity);

   479 	CPlayer *pPlayer = &m_Players[client];

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

   482 	if (!pPlayer->IsConnected())

   483 	{

   484 		/* Run manual connection routines */

   485 		char error[255];

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

   487 		pPlayer->Authorize(authid);

   488 		pPlayer->m_bFakeClient = true;

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

   490 		{

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

   492 			return;

   493 		}

   494 		List<IClientListener *>::iterator iter;

   495 		IClientListener *pListener = NULL;

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

   497 		{

   498 			pListener = (*iter);

   499 			pListener->OnClientConnected(client);

   500 			/* See if bot was kicked */

   501 			if (!pPlayer->IsConnected())

   502 			{

   503 				return;

   504 			}

   505 		}

   506 		/* Now do authorization */

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

   508 		{

   509 			pListener = (*iter);

   510 			pListener->OnClientAuthorized(client, authid);

   511 		}

   512 		/* Finally, tell plugins */

   513 		if (m_clauth->GetFunctionCount())

   514 		{

   515 			m_clauth->PushCell(client);

   516 			m_clauth->PushString(authid);

   517 			m_clauth->Execute(NULL);

   518 		}

   519 		pPlayer->Authorize_Post();

   520 	}

   522 	if (playerinfo)

   523 	{

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

   525 	}

   527 	/* Get the client's language */

   528 	if (m_QueryLang)

   529 	{

   530 		const char *name;

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

   532 		{

   533 			unsigned int langid;

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

   535 		} else {

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

   537 		}

   538 	}

   540 	pPlayer->Connect();

   541 	m_PlayerCount++;

   543 	List<IClientListener *>::iterator iter;

   544 	IClientListener *pListener = NULL;

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

   546 	{

   547 		pListener = (*iter);

   548 		pListener->OnClientPutInServer(client);

   549 	}

   551 	m_clputinserver->PushCell(client);

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

   554 	if (pPlayer->IsAuthorized())

   555 	{

   556 		pPlayer->DoPostConnectAuthorization();

   557 	}

   558 }

   560 void PlayerManager::OnSourceModLevelEnd()

   561 {

   562 	/* Disconnect all bots still in game */

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

   564 	{

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

   566 		{

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

   568 		}

   569 	}

   570 	m_PlayerCount = 0;

   571 }

   573 void PlayerManager::OnClientDisconnect(edict_t *pEntity)

   574 {

   575 	cell_t res;

   576 	int client = IndexOfEdict(pEntity);

   577 	CPlayer *pPlayer = &m_Players[client];

   579 	if (pPlayer->IsConnected())

   580 	{

   581 		m_cldisconnect->PushCell(client);

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

   583 	}

   584 	else

   585 	{

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

   587 		return;

   588 	}

   590 	if (pPlayer->WasCountedAsInGame())

   591 	{

   592 		m_PlayerCount--;

   593 	}

   595 	List<IClientListener *>::iterator iter;

   596 	IClientListener *pListener = NULL;

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

   598 	{

   599 		pListener = (*iter);

   600 		pListener->OnClientDisconnecting(client);

   601 	}

   603 	InvalidatePlayer(pPlayer);

   605 	if (m_ListenClient == client)

   606 	{

   607 		m_ListenClient = 0;

   608 	}

   609 }

   611 void PlayerManager::OnClientDisconnect_Post(edict_t *pEntity)

   612 {

   613 	cell_t res;

   614 	int client = IndexOfEdict(pEntity);

   616 	m_cldisconnect_post->PushCell(client);

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

   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->OnClientDisconnected(client);

   625 	}

   626 }

   628 #if SOURCE_ENGINE >= SE_ORANGEBOX

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

   630 {

   631 #else

   632 void PlayerManager::OnClientCommand(edict_t *pEntity)

   633 {

   634 	CCommand args;

   635 #endif

   636 	int client = IndexOfEdict(pEntity);

   637 	cell_t res = Pl_Continue;

   638 	CPlayer *pPlayer = &m_Players[client];

   640 	if (!pPlayer->IsConnected())

   641 	{

   642 		return;

   643 	}

   645 	g_HL2.PushCommandStack(&args);

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

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

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

   651 	if (result)

   652 	{

   653 		res = Pl_Handled;

   654 	} else {

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

   656 		if (result)

   657 		{

   658 			res = Pl_Handled;

   659 		}

   660 	}

   662 	cell_t res2 = Pl_Continue;

   663 	m_clcommand->PushCell(client);

   664 	m_clcommand->PushCell(argcount);

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

   667 	if (res2 > res)

   668 	{

   669 		res = res2;

   670 	}

   672 	if (res >= Pl_Stop)

   673 	{

   674 		g_HL2.PopCommandStack();

   675 		RETURN_META(MRES_SUPERCEDE);

   676 	}

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

   680 	g_HL2.PopCommandStack();

   682 	if (res >= Pl_Handled)

   683 	{

   684 		RETURN_META(MRES_SUPERCEDE);

   685 	}

   686 }

   688 void PlayerManager::OnClientSettingsChanged(edict_t *pEntity)

   689 {

   690 	cell_t res;

   691 	int client = IndexOfEdict(pEntity);

   692 	CPlayer *pPlayer = &m_Players[client];

   694 	if (!pPlayer->IsConnected())

   695 	{

   696 		return;

   697 	}

   699 	m_clinfochanged->PushCell(client);

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

   702 	if (pPlayer->IsFakeClient())

   703 	{

   704 		return;

   705 	}

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

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

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

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

   712 	{

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

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

   715 		{

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

   717 			{

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

   719 				RETURN_META(MRES_IGNORED);

   720 			}

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

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

   723 			{

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

   725 				pPlayer->SetAdminId(INVALID_ADMIN_ID, false);

   726 			}

   727 		}

   728 		pPlayer->SetName(new_name);

   729 	}

   731 	if (m_PassInfoVar.size() > 0)

   732 	{

   733 		/* Try for a password change */

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

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

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

   737 		{

   738 			pPlayer->m_LastPassword.assign(new_pass);

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

   740 			{

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

   742 				pPlayer->DoBasicAdminChecks();

   743 			}

   744 		}

   745 	}

   746 }

   748 int PlayerManager::GetMaxClients()

   749 {

   750 	return m_maxClients;

   751 }

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

   754 {

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

   756 	{

   757 		return NULL;

   758 	}

   759 	return &m_Players[client];

   760 }

   762 int PlayerManager::GetNumPlayers()

   763 {

   764 	return m_PlayerCount;

   765 }

   767 int PlayerManager::GetClientOfUserId(int userid)

   768 {

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

   770 	{

   771 		return 0;

   772 	}

   774 	int client = m_UserIdLookUp[userid];

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

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

   778 	 * check before invoking this backwards compat code.

   779 	 */

   780 	if (client)

   781 	{

   782 		CPlayer *player = GetPlayerByIndex(client);

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

   784 		{

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

   786 			if (realUserId == userid)

   787 			{

   788 				return client;

   789 			}

   790 		}

   791 	}

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

   794 	CPlayer *player;

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

   796 	{

   797 		player = GetPlayerByIndex(i);

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

   799 		{

   800 			continue;

   801 		}

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

   803 		{

   804 			m_UserIdLookUp[userid] = i;

   805 			return i;

   806 		}

   807 	}

   809 	return 0;

   810 }

   812 void PlayerManager::AddClientListener(IClientListener *listener)

   813 {

   814 	m_hooks.push_back(listener);

   815 }

   817 void PlayerManager::RemoveClientListener(IClientListener *listener)

   818 {

   819 	m_hooks.remove(listener);

   820 }

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

   823 {

   824 	int index = IndexOfEdict(pEdict);

   825 	return GetGamePlayer(index);

   826 }

   828 IGamePlayer *PlayerManager::GetGamePlayer(int client)

   829 {

   830 	return GetPlayerByIndex(client);

   831 }

   833 void PlayerManager::ClearAdminId(AdminId id)

   834 {

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

   836 	{

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

   838 		{

   839 			m_Players[i].DumpAdmin(true);

   840 		}

   841 	}

   842 }

   844 void PlayerManager::ClearAllAdmins()

   845 {

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

   847 	{

   848 		m_Players[i].DumpAdmin(true);

   849 	}

   850 }

   852 const char *PlayerManager::GetPassInfoVar()

   853 {

   854 	return m_PassInfoVar.c_str();

   855 }

   857 void PlayerManager::RecheckAnyAdmins()

   858 {

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

   860 	{

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

   862 		{

   863 			m_Players[i].DoBasicAdminChecks();

   864 		}

   865 	}

   866 }

   868 unsigned int PlayerManager::GetReplyTo()

   869 {

   870 	return g_ChatTriggers.GetReplyTo();

   871 }

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

   874 {

   875 	return g_ChatTriggers.SetReplyTo(reply);

   876 }

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

   879 {

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

   881 }

   883 void PlayerManager::RegisterCommandTargetProcessor(ICommandTargetProcessor *pHandler)

   884 {

   885 	target_processors.push_back(pHandler);

   886 }

   888 void PlayerManager::UnregisterCommandTargetProcessor(ICommandTargetProcessor *pHandler)

   889 {

   890 	target_processors.remove(pHandler);

   891 }

   893 void PlayerManager::InvalidatePlayer(CPlayer *pPlayer)

   894 {

   895 	/**

   896 	* Remove client from auth queue if necessary

   897 	*/

   898 	if (!pPlayer->IsAuthorized())

   899 	{

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

   901 		{

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

   903 			{

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

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

   906 				{

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

   908 				}

   909 				/* Remove us and break */

   910 				m_AuthQueue[0]--;

   911 				break;

   912 			}

   913 		}

   914 	}

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

   917 	pPlayer->Disconnect();

   918 }

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

   921 {

   922 	if ((flags & COMMAND_FILTER_CONNECTED) == COMMAND_FILTER_CONNECTED

   923 		&& !pTarget->IsConnected())

   924 	{

   925 		return COMMAND_TARGET_NONE;

   926 	}

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

   928 		!pTarget->IsInGame())

   929 	{

   930 		return COMMAND_TARGET_NOT_IN_GAME;

   931 	}

   933 	if ((flags & COMMAND_FILTER_NO_BOTS) == COMMAND_FILTER_NO_BOTS

   934 		&& pTarget->IsFakeClient())

   935 	{

   936 		return COMMAND_TARGET_NOT_HUMAN;

   937 	}

   939 	if (pAdmin != NULL)

   940 	{

   941 		if ((flags & COMMAND_FILTER_NO_IMMUNITY) != COMMAND_FILTER_NO_IMMUNITY

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

   943 		{

   944 			return COMMAND_TARGET_IMMUNE;

   945 		}

   946 	}

   948 	if ((flags & COMMAND_FILTER_ALIVE) == COMMAND_FILTER_ALIVE

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

   950 	{

   951 		return COMMAND_TARGET_NOT_ALIVE;

   952 	}

   954 	if ((flags & COMMAND_FILTER_DEAD) == COMMAND_FILTER_DEAD

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

   956 	{

   957 		return COMMAND_TARGET_NOT_DEAD;

   958 	}

   960 	return COMMAND_TARGET_VALID;

   961 }

   963 void PlayerManager::ProcessCommandTarget(cmd_target_info_t *info)

   964 {

   965 	CPlayer *pTarget, *pAdmin;

   966 	int max_clients, total = 0;

   968 	max_clients = GetMaxClients();

   970 	if (info->max_targets < 1)

   971 	{

   972 		info->reason = COMMAND_TARGET_NONE;

   973 		info->num_targets = 0;

   974 	}

   976 	if (info->admin == 0)

   977 	{

   978 		pAdmin = NULL;

   979 	}

   980 	else

   981 	{

   982 		pAdmin = GetPlayerByIndex(info->admin);

   983 	}

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

   986 	{

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

   988 		int client = GetClientOfUserId(userid);

   990 		/* See if a valid userid matched */

   991 		if (client > 0)

   992 		{

   993 			IGamePlayer *pTarget = GetPlayerByIndex(client);

   994 			if (pTarget != NULL)

   995 			{

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

   997 				{

   998 					info->targets[0] = client;

   999 					info->num_targets = 1;

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

  1001 					info->target_name_style = COMMAND_TARGETNAME_RAW;

  1002 				}

  1003 				else

  1004 				{

  1005 					info->num_targets = 0;

  1006 				}

  1007 				return;

  1008 			}

  1009 		}

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

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

  1013 		{

  1014 			size_t p, len;

  1015 			char new_pattern[256];

  1017 			strcpy(new_pattern, "STEAM_");

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

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

  1020 			{

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

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

  1023 				{

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

  1025 				}

  1026 			}

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

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

  1030 			{

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

  1032 				{

  1033 					continue;

  1034 				}

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

  1036 				{

  1037 					continue;

  1038 				}

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

  1040 				{

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

  1042 						== COMMAND_TARGET_VALID)

  1043 					{

  1044 						info->targets[0] = i;

  1045 						info->num_targets = 1;

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

  1047 						info->target_name_style = COMMAND_TARGETNAME_RAW;

  1048 					}

  1049 					else

  1050 					{

  1051 						info->num_targets = 0;

  1052 					}

  1053 					return;

  1054 				}

  1055 			}

  1056 		}

  1058 		/* See if an exact name matches */

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

  1060 		{

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

  1062 			{

  1063 				continue;

  1064 			}

  1065 			if  (!pTarget->IsConnected())

  1066 			{

  1067 				continue;

  1068 			}

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

  1070 			{

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

  1072 					== COMMAND_TARGET_VALID)

  1073 				{

  1074 					info->targets[0] = i;

  1075 					info->num_targets = 1;

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

  1077 					info->target_name_style = COMMAND_TARGETNAME_RAW;

  1078 				}

  1079 				else

  1080 				{

  1081 					info->num_targets = 0;

  1082 				}

  1083 				return;

  1084 			}

  1085 		}

  1086 	}

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

  1089 	{

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

  1091 		info->num_targets = 1;

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

  1093 		info->target_name_style = COMMAND_TARGETNAME_RAW;

  1094 		return;

  1095 	}

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

  1098 	{

  1099 		bool is_multi = false;

  1100 		bool bots_only = false;

  1101 		int skip_client = -1;

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

  1104 		{

  1105 			is_multi = true;

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

  1107 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1108 		}

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

  1110 		{

  1111 			is_multi = true;

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

  1113 			{

  1114 				info->num_targets = 0;

  1115 				info->reason = COMMAND_TARGET_NOT_ALIVE;

  1116 				return;

  1117 			}

  1118 			info->flags |= COMMAND_FILTER_DEAD;

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

  1120 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1121 		}

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

  1123 		{

  1124 			is_multi = true;

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

  1126 			{

  1127 				info->num_targets = 0;

  1128 				info->reason = COMMAND_TARGET_NOT_DEAD;

  1129 				return;

  1130 			}

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

  1132 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1133 			info->flags |= COMMAND_FILTER_ALIVE;

  1134 		}

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

  1136 		{

  1137 			is_multi = true;

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

  1139 			{

  1140 				info->num_targets = 0;

  1141 				info->reason = COMMAND_FILTER_NO_BOTS;

  1142 				return;

  1143 			}

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

  1145 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1146 			bots_only = true;

  1147 		}

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

  1149 		{

  1150 			is_multi = true;

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

  1152 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1153 			info->flags |= COMMAND_FILTER_NO_BOTS;

  1154 		}

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

  1156 		{

  1157 			is_multi = true;

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

  1159 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1160 			skip_client = info->admin;

  1161 		}

  1163 		if (is_multi)

  1164 		{

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

  1166 			{

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

  1168 				{

  1169 					continue;

  1170 				}

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

  1172 				{

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

  1174 						&& skip_client != i)

  1175 					{

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

  1177 					}

  1178 				}

  1179 			}

  1181 			info->num_targets = total;

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

  1183 			return;

  1184 		}

  1185 	}

  1187 	List<ICommandTargetProcessor *>::iterator iter;

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

  1189 	{

  1190 		ICommandTargetProcessor *pProcessor = (*iter);

  1191 		if (pProcessor->ProcessCommandTarget(info))

  1192 		{

  1193 			return;

  1194 		}

  1195 	}

  1197 	/* Check partial names */

  1198 	int found_client = 0;

  1199 	CPlayer *pFoundClient = NULL;

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

  1201 	{

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

  1203 		{

  1204 			continue;

  1205 		}

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

  1208 		{

  1209 			if (found_client)

  1210 			{

  1211 				info->num_targets = 0;

  1212 				info->reason = COMMAND_TARGET_AMBIGUOUS;

  1213 				return;

  1214 			}

  1215 			else

  1216 			{

  1217 				found_client = i;

  1218 				pFoundClient = pTarget;

  1219 			}

  1220 		}

  1221 	}

  1223 	if (found_client)

  1224 	{

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

  1226 			== COMMAND_TARGET_VALID)

  1227 		{

  1228 			info->targets[0] = found_client;

  1229 			info->num_targets = 1;

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

  1231 			info->target_name_style = COMMAND_TARGETNAME_RAW;

  1232 		}

  1233 		else

  1234 		{

  1235 			info->num_targets = 0;

  1236 		}

  1237 	}

  1238 	else

  1239 	{

  1240 		info->num_targets = 0;

  1241 		info->reason = COMMAND_TARGET_NONE;

  1242 	}

  1243 }

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

  1246 {

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

  1248 	{

  1249 		MaxPlayersChanged(gpGlobals->maxClients + 1);

  1250 	}

  1251 	else

  1252 	{

  1253 		MaxPlayersChanged();

  1254 	}

  1255 }

  1257 void PlayerManager::OnSourceModMaxPlayersChanged( int newvalue )

  1258 {

  1259 	m_maxClients = newvalue;

  1260 }

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

  1263 {

  1264 	if (newvalue == -1)

  1265 	{

  1266 		newvalue = gpGlobals->maxClients;

  1267 	}

  1269 	if (newvalue == MaxClients())

  1270 	{

  1271 		return;

  1272 	}

  1274 	/* Notify the rest of core */

  1275 	SMGlobalClass *pBase = SMGlobalClass::head;

  1276 	while (pBase)

  1277 	{

  1278 		pBase->OnSourceModMaxPlayersChanged(newvalue);

  1279 		pBase = pBase->m_pGlobalClassNext;

  1280 	}

  1282 	/* Notify Extensions */

  1283 	List<IClientListener *>::iterator iter;

  1284 	IClientListener *pListener = NULL;

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

  1286 	{

  1287 		pListener = (*iter);

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

  1289 		{

  1290 			pListener->OnMaxPlayersChanged(newvalue);

  1291 		}

  1292 	}

  1293 }

  1295 #if SOURCE_ENGINE >= SE_ORANGEBOX

  1296 void CmdMaxplayersCallback(const CCommand &command)

  1297 {

  1298 #else

  1299 void CmdMaxplayersCallback()

  1300 {

  1301 #endif

  1303 	g_Players.MaxPlayersChanged();

  1304 }

  1307 /*******************

  1308  *** PLAYER CODE ***

  1309  *******************/

  1311 CPlayer::CPlayer()

  1312 {

  1313 	m_IsConnected = false;

  1314 	m_IsInGame = false;

  1315 	m_IsAuthorized = false;

  1316 	m_pEdict = NULL;

  1317 	m_Admin = INVALID_ADMIN_ID;

  1318 	m_TempAdmin = false;

  1319 	m_Info = NULL;

  1320 	m_bAdminCheckSignalled = false;

  1321 	m_bIsInKickQueue = false;

  1322 	m_LastPassword.clear();

  1323 	m_LangId = SOURCEMOD_LANGUAGE_ENGLISH;

  1324 	m_bFakeClient = false;

  1325 }

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

  1328 {

  1329 	m_IsConnected = true;

  1330 	m_Name.assign(name);

  1331 	m_Ip.assign(ip);

  1332 	m_pEdict = pEntity;

  1333 	m_iIndex = IndexOfEdict(pEntity);

  1334 	m_LangId = g_Translator.GetServerLanguage();

  1336 	char ip2[24], *ptr;

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

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

  1339 	{

  1340 		*ptr = '\0';

  1341 	}

  1342 	m_IpNoPort.assign(ip2);

  1343 }

  1345 void CPlayer::Connect()

  1346 {

  1347 	if (m_IsInGame)

  1348 	{

  1349 		return;

  1350 	}

  1352 	m_IsInGame = true;

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

  1355 	int client = IndexOfEdict(m_pEdict);

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

  1357 	{

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

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

  1360 	}

  1361 	else

  1362 	{

  1363 		m_LastPassword.assign("");

  1364 	}

  1365 }

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

  1368 {

  1369 	if (m_IsAuthorized)

  1370 	{

  1371 		return;

  1372 	}

  1374 	m_IsAuthorized = true;

  1375 	m_AuthID.assign(steamid);

  1376 }

  1378 void CPlayer::Disconnect()

  1379 {

  1380 	DumpAdmin(false);

  1381 	m_IsConnected = false;

  1382 	m_IsInGame = false;

  1383 	m_IsAuthorized = false;

  1384 	m_Name.clear();

  1385 	m_Ip.clear();

  1386 	m_AuthID.clear();

  1387 	m_pEdict = NULL;

  1388 	m_Info = NULL;

  1389 	m_bAdminCheckSignalled = false;

  1390 	m_UserId = -1;

  1391 	m_bIsInKickQueue = false;

  1392 	m_bFakeClient = false;

  1393 }

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

  1396 {

  1397 	m_Name.assign(name);

  1398 }

  1400 const char *CPlayer::GetName()

  1401 {

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

  1403 	{

  1404 		return m_Info->GetName();

  1405 	}

  1407 	return m_Name.c_str();

  1408 }

  1410 const char *CPlayer::GetIPAddress()

  1411 {

  1412 	return m_Ip.c_str();

  1413 }

  1415 const char *CPlayer::GetAuthString()

  1416 {

  1417 	return m_AuthID.c_str();

  1418 }

  1420 edict_t *CPlayer::GetEdict()

  1421 {

  1422 	return m_pEdict;

  1423 }

  1425 bool CPlayer::IsInGame()

  1426 {

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

  1428 }

  1430 bool CPlayer::WasCountedAsInGame()

  1431 {

  1432 	return m_IsInGame;

  1433 }

  1435 bool CPlayer::IsConnected()

  1436 {

  1437 	return m_IsConnected;

  1438 }

  1440 bool CPlayer::IsAuthorized()

  1441 {

  1442 	return m_IsAuthorized;

  1443 }

  1445 IPlayerInfo *CPlayer::GetPlayerInfo()

  1446 {

  1447 	if (m_pEdict->GetUnknown())

  1448 	{

  1449 		return m_Info;

  1450 	}

  1452 	return NULL;

  1453 }

  1455 bool CPlayer::IsFakeClient()

  1456 {

  1457 	return m_bFakeClient;

  1458 }

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

  1461 {

  1462 	if (!m_IsConnected)

  1463 	{

  1464 		return;

  1465 	}

  1467 	DumpAdmin(false);

  1469 	m_Admin = id;

  1470 	m_TempAdmin = temporary;

  1471 }

  1473 AdminId CPlayer::GetAdminId()

  1474 {

  1475 	return m_Admin;

  1476 }

  1478 void CPlayer::DumpAdmin(bool deleting)

  1479 {

  1480 	if (m_Admin != INVALID_ADMIN_ID)

  1481 	{

  1482 		if (m_TempAdmin && !deleting)

  1483 		{

  1484 			g_Admins.InvalidateAdmin(m_Admin);

  1485 		}

  1486 		m_Admin = INVALID_ADMIN_ID;

  1487 		m_TempAdmin = false;

  1488 	}

  1489 }

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

  1492 {

  1493 	MarkAsBeingKicked();

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

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

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

  1497 }

  1499 void CPlayer::Authorize_Post()

  1500 {

  1501 	if (m_IsInGame)

  1502 	{

  1503 		DoPostConnectAuthorization();

  1504 	}

  1505 }

  1507 void CPlayer::DoPostConnectAuthorization()

  1508 {

  1509 	bool delay = false;

  1511 	List<IClientListener *>::iterator iter;

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

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

  1514 		 iter++)

  1515 	{

  1516 		IClientListener *pListener = (*iter);

  1517 #if defined MIN_API_FOR_ADMINCALLS

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

  1519 		{

  1520 			continue;

  1521 		}

  1522 #endif

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

  1524 		{

  1525 			delay = true;

  1526 		}

  1527 	}

  1529 	cell_t result = 0;

  1530 	PreAdminCheck->PushCell(m_iIndex);

  1531 	PreAdminCheck->Execute(&result);

  1533 	/* Defer, for better or worse */

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

  1535 	{

  1536 		return;

  1537 	}

  1539 	/* Sanity check */

  1540 	if (!IsConnected())

  1541 	{

  1542 		return;

  1543 	}

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

  1546 	DoBasicAdminChecks();

  1548 	/* Send the notification out */

  1549 	NotifyPostAdminChecks();

  1550 }

  1552 bool CPlayer::RunAdminCacheChecks()

  1553 {

  1554 	AdminId old_id = GetAdminId();

  1556 	DoBasicAdminChecks();

  1558 	return (GetAdminId() != old_id);

  1559 }

  1561 void CPlayer::NotifyPostAdminChecks()

  1562 {

  1563 	if (m_bAdminCheckSignalled)

  1564 	{

  1565 		return;

  1566 	}

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

  1569 	m_bAdminCheckSignalled = true;

  1571 	List<IClientListener *>::iterator iter;

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

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

  1574 		iter++)

  1575 	{

  1576 		IClientListener *pListener = (*iter);

  1577 #if defined MIN_API_FOR_ADMINCALLS

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

  1579 		{

  1580 			continue;

  1581 		}

  1582 #endif

  1583 		pListener->OnClientPostAdminCheck(m_iIndex);

  1584 	}

  1586 	PostAdminFilter->PushCell(m_iIndex);

  1587 	PostAdminFilter->Execute(NULL);

  1589 	PostAdminCheck->PushCell(m_iIndex);

  1590 	PostAdminCheck->Execute(NULL);

  1591 }

  1593 void CPlayer::DoBasicAdminChecks()

  1594 {

  1595 	if (GetAdminId() != INVALID_ADMIN_ID)

  1596 	{

  1597 		return;

  1598 	}

  1600 	/* First check the name */

  1601 	AdminId id;

  1602 	int client = IndexOfEdict(m_pEdict);

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

  1605 	{

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

  1607 		{

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

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

  1610 		}

  1611 		return;

  1612 	}

  1614 	/* Check IP */

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

  1616 	{

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

  1618 		{

  1619 			return;

  1620 		}

  1621 	}

  1623 	/* Check IP address */

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

  1625 	{

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

  1627 		{

  1628 			return;

  1629 		}

  1630 	}

  1631 }

  1633 unsigned int CPlayer::GetLanguageId()

  1634 {

  1635 	return m_LangId;

  1636 }

  1638 int CPlayer::GetUserId()

  1639 {

  1640 	if (m_UserId == -1)

  1641 	{

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

  1643 	}

  1645 	return m_UserId;

  1646 }

  1648 bool CPlayer::IsInKickQueue()

  1649 {

  1650 	return m_bIsInKickQueue;

  1651 }

  1653 void CPlayer::MarkAsBeingKicked()

  1654 {

  1655 	m_bIsInKickQueue = true;

  1656 }

  1658 int CPlayer::GetLifeState()

  1659 {

  1660 	if (lifestate_offset == -1)

  1661 	{

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

  1663 		{

  1664 			lifestate_offset = -2;

  1665 		}

  1666 	}

  1668 	if (lifestate_offset < 0)

  1669 	{

  1670 		IPlayerInfo *info = GetPlayerInfo();

  1671 		if (info == NULL)

  1672 		{

  1673 			return PLAYER_LIFE_UNKNOWN;

  1674 		}

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

  1676 	}

  1678 	if (m_pEdict == NULL)

  1679 	{

  1680 		return PLAYER_LIFE_UNKNOWN;

  1681 	}

  1683 	CBaseEntity *pEntity;

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

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

  1686 	{

  1687 		return PLAYER_LIFE_UNKNOWN;

  1688 	}

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

  1691 	{

  1692 		return PLAYER_LIFE_ALIVE;

  1693 	}

  1694 	else

  1695 	{

  1696 		return PLAYER_LIFE_DEAD;

  1697 	}

  1698 }

author	Scott Ehlert <ds@alliedmods.net>
	Fri Nov 21 14:09:50 2008 -0600 (2008-11-21)
changeset 2417	3a64d2bc51c1
parent 2413	f7fee39a0e56
child 2421	1c26fcdc2be0
permissions	-rw-r--r--