sourcemod-central: core/PlayerManager.cpp@4403a982ec91

     1 /**

     2  * vim: set ts=4 :

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

     4  * SourceMod

     5  * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.

     6  * =============================================================================

     7  *

     8  * This program is free software; you can redistribute it and/or modify it under

     9  * the terms of the GNU General Public License, version 3.0, as published by the

    10  * Free Software Foundation.

    11  *

    12  * This program is distributed in the hope that it will be useful, but WITHOUT

    13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

    14  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more

    15  * details.

    16  *

    17  * You should have received a copy of the GNU General Public License along with

    18  * this program.  If not, see <http://www.gnu.org/licenses/>.

    19  *

    20  * As a special exception, AlliedModders LLC gives you permission to link the

    21  * code of this program (as well as its derivative works) to "Half-Life 2," the

    22  * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software

    23  * by the Valve Corporation.  You must obey the GNU General Public License in

    24  * all respects for all other code used.  Additionally, AlliedModders LLC grants

    25  * this exception to all derivative works.  AlliedModders LLC defines further

    26  * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),

    27  * or <http://www.sourcemod.net/license.php>.

    28  *

    29  * Version: $Id$

    30  */

    32 #include "PlayerManager.h"

    33 #include "ForwardSys.h"

    34 #include "ShareSys.h"

    35 #include "AdminCache.h"

    36 #include "ConCmdManager.h"

    37 #include "MenuStyle_Valve.h"

    38 #include "MenuStyle_Radio.h"

    39 #include "sm_stringutil.h"

    40 #include "CoreConfig.h"

    41 #include "TimerSys.h"

    42 #include "Translator.h"

    43 #include "Logger.h"

    44 #include "ChatTriggers.h"

    45 #include "HalfLife2.h"

    46 #include <inetchannel.h>

    47 #include <iclient.h>

    48 #include "GameConfigs.h"

    49 #include "systems/ExtensionSys.h"

    51 PlayerManager g_Players;

    52 bool g_OnMapStarted = false;

    53 IForward *PreAdminCheck = NULL;

    54 IForward *PostAdminCheck = NULL;

    55 IForward *PostAdminFilter = NULL;

    56 const unsigned int *g_NumPlayersToAuth = NULL;

    57 int lifestate_offset = -1;

    58 List<ICommandTargetProcessor *> target_processors;

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

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

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

    63 #if defined ORANGEBOX_BUILD

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

    65 #else

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

    67 #endif

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

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

    71 class KickPlayerTimer : public ITimedEvent

    72 {

    73 public:

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

    75 	{

    76 		int userid = (int)pData;

    77 		int client = g_Players.GetClientOfUserId(userid);

    78 		if (client)

    79 		{

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

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

    82 		}

    83 		return Pl_Stop;

    84 	}

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

    86 	{

    87 	}

    88 } s_KickPlayerTimer;

    90 PlayerManager::PlayerManager()

    91 {

    92 	m_AuthQueue = NULL;

    93 	m_FirstPass = false;

    94 	m_maxClients = 0;

    96 	m_UserIdLookUp = new int[USHRT_MAX+1];

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

    98 }

   100 PlayerManager::~PlayerManager()

   101 {

   102 	g_NumPlayersToAuth = NULL;

   104 	delete [] m_AuthQueue;

   105 	delete [] m_UserIdLookUp;

   106 }

   108 void PlayerManager::OnSourceModAllInitialized()

   109 {

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

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

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

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

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

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

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

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

   119 	g_ShareSys.AddInterface(NULL, this);

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

   122 	ParamType p2[] = {Param_Cell};

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

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

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

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

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

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

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

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

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

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

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

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

   138 	m_bIsListenServer = !engine->IsDedicatedServer();

   139 	m_ListenClient = 0;

   140 }

   142 void PlayerManager::OnSourceModShutdown()

   143 {

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

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

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

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

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

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

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

   152 	/* Release forwards */

   153 	g_Forwards.ReleaseForward(m_clconnect);

   154 	g_Forwards.ReleaseForward(m_clputinserver);

   155 	g_Forwards.ReleaseForward(m_cldisconnect);

   156 	g_Forwards.ReleaseForward(m_cldisconnect_post);

   157 	g_Forwards.ReleaseForward(m_clcommand);

   158 	g_Forwards.ReleaseForward(m_clinfochanged);

   159 	g_Forwards.ReleaseForward(m_clauth);

   160 	g_Forwards.ReleaseForward(m_onActivate);

   161 	g_Forwards.ReleaseForward(m_onActivate2);

   163 	g_Forwards.ReleaseForward(PreAdminCheck);

   164 	g_Forwards.ReleaseForward(PostAdminCheck);

   165 	g_Forwards.ReleaseForward(PostAdminFilter);

   167 	delete [] m_Players;

   168 }

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

   171 												 const char *value,

   172 												 ConfigSource source,

   173 												 char *error,

   174 												 size_t maxlength)

   175 {

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

   177 	{

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

   179 		{

   180 			m_PassInfoVar.assign(value);

   181 		}

   182 		return ConfigResult_Accept;

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

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

   185 		{

   186 			m_QueryLang = true;

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

   188 			m_QueryLang = false;

   189 		} else {

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

   191 			return ConfigResult_Reject;

   192 		}

   193 		return ConfigResult_Accept;

   194 	}

   195 	return ConfigResult_Ignore;

   196 }

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

   199 {

   200 	if (!m_FirstPass)

   201 	{

   202 		/* Initialize all players */

   203 		m_maxClients = clientMax;

   204 		m_PlayerCount = 0;

   205 		m_Players = new CPlayer[m_maxClients + 1];

   206 		m_AuthQueue = new unsigned int[m_maxClients + 1];

   207 		m_FirstPass = true;

   209 		memset(m_AuthQueue, 0, sizeof(unsigned int) * (m_maxClients + 1));

   211 		g_NumPlayersToAuth = &m_AuthQueue[0];

   212 	}

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

   214 	m_onActivate->Execute(NULL);

   215 	m_onActivate2->Execute(NULL);

   217 	List<IClientListener *>::iterator iter;

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

   219 	{

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

   221 		{

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

   223 		}

   224 	}

   226 	g_OnMapStarted = true;

   228 	SM_ExecuteAllConfigs();

   229 }

   231 bool PlayerManager::IsServerActivated()

   232 {

   233 	return m_FirstPass;

   234 }

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

   237 {

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

   239 	if (password != NULL)

   240 	{

   241 		if (m_PassInfoVar.size() < 1)

   242 		{

   243 			return false;

   244 		}

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

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

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

   249 		{

   250 			return false;

   251 		}

   252 	}

   254 	pPlayer->SetAdminId(id, false);

   256 	return true;

   257 }

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

   260 {

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

   262 	if (password == NULL)

   263 	{

   264 		return false;

   265 	}

   267 	if (m_PassInfoVar.size() < 1)

   268 	{

   269 		return false;

   270 	}

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

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

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

   275 	{

   276 		return false;

   277 	}

   279 	pPlayer->SetAdminId(id, false);

   281 	return true;

   282 }

   284 void PlayerManager::RunAuthChecks()

   285 {

   286 	CPlayer *pPlayer;

   287 	const char *authstr;

   288 	unsigned int removed = 0;

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

   290 	{

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

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

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

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

   295 		{

   296 			/* Set authorization */

   297 			pPlayer->Authorize(authstr);

   299 			/* Mark as removed from queue */

   300 			unsigned int client = m_AuthQueue[i];

   301 			m_AuthQueue[i] = 0;

   302 			removed++;

   304 			/* Send to extensions */

   305 			List<IClientListener *>::iterator iter;

   306 			IClientListener *pListener;

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

   308 			{

   309 				pListener = (*iter);

   310 				pListener->OnClientAuthorized(client, authstr);

   311 				if (!pPlayer->IsConnected())

   312 				{

   313 					break;

   314 				}

   315 			}

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

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

   319 			{

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

   321 				m_clauth->PushCell(client);

   322 				m_clauth->PushString(authstr);

   323 				m_clauth->Execute(NULL);

   324 			}

   326 			if (pPlayer->IsConnected())

   327 			{

   328 				pPlayer->Authorize_Post();

   329 			}

   330 		}

   331 	}

   333 	/* Clean up the queue */

   334 	if (removed)

   335 	{

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

   337 		if (removed != m_AuthQueue[0])

   338 		{

   339 			unsigned int diff = 0;

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

   341 			{

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

   343 				if (m_AuthQueue[i] == 0)

   344 				{

   345 					/* Increase the differential */

   346 					diff++;

   347 				} else {

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

   349 					assert(i > diff);

   350 					assert(i - diff >= 1);

   351 					/* move this index down */

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

   353 				}

   354 			}

   355 			m_AuthQueue[0] -= removed;

   356 		} else {

   357 			m_AuthQueue[0] = 0;

   358 		}

   359 	}

   360 }

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

   363 {

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

   365 	CPlayer *pPlayer = &m_Players[client];

   367 	List<IClientListener *>::iterator iter;

   368 	IClientListener *pListener = NULL;

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

   370 	{

   371 		pListener = (*iter);

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

   373 		{

   374 			return false;

   375 		}

   376 	}

   378 	cell_t res = 1;

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

   381 	m_clconnect->PushCell(client);

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

   383 	m_clconnect->PushCell(maxrejectlen);

   384 	m_clconnect->Execute(&res);

   386 	if (res)

   387 	{

   388 		if (!pPlayer->IsAuthorized())

   389 		{

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

   391 		}

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

   394 	}

   395 	else

   396 	{

   397 		if (!pPlayer->IsFakeClient())

   398 		{

   399 			RETURN_META_VALUE(MRES_SUPERCEDE, false);

   400 		}

   401 	}

   403 	return true;

   404 }

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

   407 {

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

   409 	bool orig_value = META_RESULT_ORIG_RET(bool);

   410 	CPlayer *pPlayer = &m_Players[client];

   412 	if (orig_value)

   413 	{

   414 		List<IClientListener *>::iterator iter;

   415 		IClientListener *pListener = NULL;

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

   417 		{

   418 			pListener = (*iter);

   419 			pListener->OnClientConnected(client);

   420 			if (!pPlayer->IsConnected())

   421 			{

   422 				break;

   423 			}

   424 		}

   426 		if (!pPlayer->IsFakeClient()

   427 			&& m_bIsListenServer

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

   429 		{

   430 			m_ListenClient = client;

   431 		}

   432 	}

   433 	else

   434 	{

   435 		InvalidatePlayer(pPlayer);

   436 	}

   438 	return true;

   439 }

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

   442 {

   443 	cell_t res;

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

   445 	CPlayer *pPlayer = &m_Players[client];

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

   448 	if (!pPlayer->IsConnected())

   449 	{

   450 		/* Run manual connection routines */

   451 		char error[255];

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

   453 		pPlayer->Authorize(authid);

   454 		pPlayer->m_bFakeClient = true;

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

   456 		{

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

   458 			return;

   459 		}

   460 		List<IClientListener *>::iterator iter;

   461 		IClientListener *pListener = NULL;

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

   463 		{

   464 			pListener = (*iter);

   465 			pListener->OnClientConnected(client);

   466 			/* See if bot was kicked */

   467 			if (!pPlayer->IsConnected())

   468 			{

   469 				return;

   470 			}

   471 		}

   472 		/* Now do authorization */

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

   474 		{

   475 			pListener = (*iter);

   476 			pListener->OnClientAuthorized(client, authid);

   477 		}

   478 		/* Finally, tell plugins */

   479 		if (m_clauth->GetFunctionCount())

   480 		{

   481 			m_clauth->PushCell(client);

   482 			m_clauth->PushString(authid);

   483 			m_clauth->Execute(NULL);

   484 		}

   485 		pPlayer->Authorize_Post();

   486 	}

   488 	if (playerinfo)

   489 	{

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

   491 	}

   493 	/* Get the client's language */

   494 	if (m_QueryLang)

   495 	{

   496 		const char *name;

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

   498 		{

   499 			unsigned int langid;

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

   501 		} else {

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

   503 		}

   504 	}

   506 	pPlayer->Connect();

   507 	m_PlayerCount++;

   509 	List<IClientListener *>::iterator iter;

   510 	IClientListener *pListener = NULL;

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

   512 	{

   513 		pListener = (*iter);

   514 		pListener->OnClientPutInServer(client);

   515 	}

   517 	m_clputinserver->PushCell(client);

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

   520 	if (pPlayer->IsAuthorized())

   521 	{

   522 		pPlayer->DoPostConnectAuthorization();

   523 	}

   524 }

   526 void PlayerManager::OnSourceModLevelEnd()

   527 {

   528 	/* Disconnect all bots still in game */

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

   530 	{

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

   532 		{

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

   534 		}

   535 	}

   536 	m_PlayerCount = 0;

   537 }

   539 void PlayerManager::OnClientDisconnect(edict_t *pEntity)

   540 {

   541 	cell_t res;

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

   543 	CPlayer *pPlayer = &m_Players[client];

   545 	if (pPlayer->IsConnected())

   546 	{

   547 		m_cldisconnect->PushCell(client);

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

   549 	}

   550 	else

   551 	{

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

   553 		return;

   554 	}

   556 	if (pPlayer->WasCountedAsInGame())

   557 	{

   558 		m_PlayerCount--;

   559 	}

   561 	List<IClientListener *>::iterator iter;

   562 	IClientListener *pListener = NULL;

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

   564 	{

   565 		pListener = (*iter);

   566 		pListener->OnClientDisconnecting(client);

   567 	}

   569 	InvalidatePlayer(pPlayer);

   571 	if (m_ListenClient == client)

   572 	{

   573 		m_ListenClient = 0;

   574 	}

   575 }

   577 void PlayerManager::OnClientDisconnect_Post(edict_t *pEntity)

   578 {

   579 	cell_t res;

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

   582 	m_cldisconnect_post->PushCell(client);

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

   585 	List<IClientListener *>::iterator iter;

   586 	IClientListener *pListener = NULL;

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

   588 	{

   589 		pListener = (*iter);

   590 		pListener->OnClientDisconnected(client);

   591 	}

   592 }

   594 #if defined ORANGEBOX_BUILD

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

   596 {

   597 #else

   598 void PlayerManager::OnClientCommand(edict_t *pEntity)

   599 {

   600 	CCommand args;

   601 #endif

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

   603 	cell_t res = Pl_Continue;

   604 	CPlayer *pPlayer = &m_Players[client];

   606 	if (!pPlayer->IsConnected())

   607 	{

   608 		return;

   609 	}

   611 	g_HL2.PushCommandStack(&args);

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

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

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

   617 	if (result)

   618 	{

   619 		res = Pl_Handled;

   620 	} else {

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

   622 		if (result)

   623 		{

   624 			res = Pl_Handled;

   625 		}

   626 	}

   628 	cell_t res2 = Pl_Continue;

   629 	m_clcommand->PushCell(client);

   630 	m_clcommand->PushCell(argcount);

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

   633 	if (res2 > res)

   634 	{

   635 		res = res2;

   636 	}

   638 	if (res >= Pl_Stop)

   639 	{

   640 		g_HL2.PopCommandStack();

   641 		RETURN_META(MRES_SUPERCEDE);

   642 	}

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

   646 	g_HL2.PopCommandStack();

   648 	if (res >= Pl_Handled)

   649 	{

   650 		RETURN_META(MRES_SUPERCEDE);

   651 	}

   652 }

   654 void PlayerManager::OnClientSettingsChanged(edict_t *pEntity)

   655 {

   656 	cell_t res;

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

   658 	CPlayer *pPlayer = &m_Players[client];

   660 	if (!pPlayer->IsConnected())

   661 	{

   662 		return;

   663 	}

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

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

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

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

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

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

   673 	{

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

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

   676 		{

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

   678 			{

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

   680 				RETURN_META(MRES_IGNORED);

   681 			}

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

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

   684 			{

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

   686 				pPlayer->SetAdminId(INVALID_ADMIN_ID, false);

   687 			}

   688 		}

   689 		pPlayer->SetName(new_name);

   690 	}

   692 	if (m_PassInfoVar.size() > 0)

   693 	{

   694 		/* Try for a password change */

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

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

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

   698 		{

   699 			pPlayer->m_LastPassword.assign(new_pass);

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

   701 			{

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

   703 				pPlayer->DoBasicAdminChecks();

   704 			}

   705 		}

   706 	}

   707 }

   709 int PlayerManager::GetMaxClients()

   710 {

   711 	return m_maxClients;

   712 }

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

   715 {

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

   717 	{

   718 		return NULL;

   719 	}

   720 	return &m_Players[client];

   721 }

   723 int PlayerManager::GetNumPlayers()

   724 {

   725 	return m_PlayerCount;

   726 }

   728 int PlayerManager::GetClientOfUserId(int userid)

   729 {

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

   731 	{

   732 		return 0;

   733 	}

   735 	int client = m_UserIdLookUp[userid];

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

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

   739 	 * check before invoking this backwards compat code.

   740 	 */

   741 	if (client)

   742 	{

   743 		CPlayer *player = GetPlayerByIndex(client);

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

   745 		{

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

   747 			if (realUserId == userid)

   748 			{

   749 				return client;

   750 			}

   751 		}

   752 	}

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

   755 	CPlayer *player;

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

   757 	{

   758 		player = GetPlayerByIndex(i);

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

   760 		{

   761 			continue;

   762 		}

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

   764 		{

   765 			m_UserIdLookUp[userid] = i;

   766 			return i;

   767 		}

   768 	}

   770 	return 0;

   771 }

   773 void PlayerManager::AddClientListener(IClientListener *listener)

   774 {

   775 	m_hooks.push_back(listener);

   776 }

   778 void PlayerManager::RemoveClientListener(IClientListener *listener)

   779 {

   780 	m_hooks.remove(listener);

   781 }

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

   784 {

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

   786 	return GetGamePlayer(index);

   787 }

   789 IGamePlayer *PlayerManager::GetGamePlayer(int client)

   790 {

   791 	return GetPlayerByIndex(client);

   792 }

   794 void PlayerManager::ClearAdminId(AdminId id)

   795 {

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

   797 	{

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

   799 		{

   800 			m_Players[i].DumpAdmin(true);

   801 		}

   802 	}

   803 }

   805 void PlayerManager::ClearAllAdmins()

   806 {

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

   808 	{

   809 		m_Players[i].DumpAdmin(true);

   810 	}

   811 }

   813 const char *PlayerManager::GetPassInfoVar()

   814 {

   815 	return m_PassInfoVar.c_str();

   816 }

   818 void PlayerManager::RecheckAnyAdmins()

   819 {

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

   821 	{

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

   823 		{

   824 			m_Players[i].DoBasicAdminChecks();

   825 		}

   826 	}

   827 }

   829 unsigned int PlayerManager::GetReplyTo()

   830 {

   831 	return g_ChatTriggers.GetReplyTo();

   832 }

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

   835 {

   836 	return g_ChatTriggers.SetReplyTo(reply);

   837 }

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

   840 {

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

   842 }

   844 void PlayerManager::RegisterCommandTargetProcessor(ICommandTargetProcessor *pHandler)

   845 {

   846 	target_processors.push_back(pHandler);

   847 }

   849 void PlayerManager::UnregisterCommandTargetProcessor(ICommandTargetProcessor *pHandler)

   850 {

   851 	target_processors.remove(pHandler);

   852 }

   854 void PlayerManager::InvalidatePlayer(CPlayer *pPlayer)

   855 {

   856 	/**

   857 	* Remove client from auth queue if necessary

   858 	*/

   859 	if (!pPlayer->IsAuthorized())

   860 	{

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

   862 		{

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

   864 			{

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

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

   867 				{

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

   869 				}

   870 				/* Remove us and break */

   871 				m_AuthQueue[0]--;

   872 				break;

   873 			}

   874 		}

   875 	}

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

   878 	pPlayer->Disconnect();

   879 }

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

   882 {

   883 	if ((flags & COMMAND_FILTER_CONNECTED) == COMMAND_FILTER_CONNECTED

   884 		&& !pTarget->IsConnected())

   885 	{

   886 		return COMMAND_TARGET_NONE;

   887 	}

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

   889 		!pTarget->IsInGame())

   890 	{

   891 		return COMMAND_TARGET_NOT_IN_GAME;

   892 	}

   894 	if ((flags & COMMAND_FILTER_NO_BOTS) == COMMAND_FILTER_NO_BOTS

   895 		&& pTarget->IsFakeClient())

   896 	{

   897 		return COMMAND_TARGET_NOT_HUMAN;

   898 	}

   900 	if (pAdmin != NULL)

   901 	{

   902 		if ((flags & COMMAND_FILTER_NO_IMMUNITY) != COMMAND_FILTER_NO_IMMUNITY

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

   904 		{

   905 			return COMMAND_TARGET_IMMUNE;

   906 		}

   907 	}

   909 	if ((flags & COMMAND_FILTER_ALIVE) == COMMAND_FILTER_ALIVE

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

   911 	{

   912 		return COMMAND_TARGET_NOT_ALIVE;

   913 	}

   915 	if ((flags & COMMAND_FILTER_DEAD) == COMMAND_FILTER_DEAD

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

   917 	{

   918 		return COMMAND_TARGET_NOT_DEAD;

   919 	}

   921 	return COMMAND_TARGET_VALID;

   922 }

   924 void PlayerManager::ProcessCommandTarget(cmd_target_info_t *info)

   925 {

   926 	CPlayer *pTarget, *pAdmin;

   927 	int max_clients, total = 0;

   929 	max_clients = GetMaxClients();

   931 	if (info->max_targets < 1)

   932 	{

   933 		info->reason = COMMAND_TARGET_NONE;

   934 		info->num_targets = 0;

   935 	}

   937 	if (info->admin == 0)

   938 	{

   939 		pAdmin = NULL;

   940 	}

   941 	else

   942 	{

   943 		pAdmin = GetPlayerByIndex(info->admin);

   944 	}

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

   947 	{

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

   949 		int client = GetClientOfUserId(userid);

   951 		/* See if a valid userid matched */

   952 		if (client > 0)

   953 		{

   954 			IGamePlayer *pTarget = GetPlayerByIndex(client);

   955 			if (pTarget != NULL)

   956 			{

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

   958 				{

   959 					info->targets[0] = client;

   960 					info->num_targets = 1;

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

   962 					info->target_name_style = COMMAND_TARGETNAME_RAW;

   963 				}

   964 				else

   965 				{

   966 					info->num_targets = 0;

   967 				}

   968 				return;

   969 			}

   970 		}

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

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

   974 		{

   975 			size_t p, len;

   976 			char new_pattern[256];

   978 			strcpy(new_pattern, "STEAM_");

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

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

   981 			{

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

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

   984 				{

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

   986 				}

   987 			}

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

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

   991 			{

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

   993 				{

   994 					continue;

   995 				}

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

   997 				{

   998 					continue;

   999 				}

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

  1001 				{

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

  1003 						== COMMAND_TARGET_VALID)

  1004 					{

  1005 						info->targets[0] = i;

  1006 						info->num_targets = 1;

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

  1008 						info->target_name_style = COMMAND_TARGETNAME_RAW;

  1009 					}

  1010 					else

  1011 					{

  1012 						info->num_targets = 0;

  1013 					}

  1014 					return;

  1015 				}

  1016 			}

  1017 		}

  1019 		/* See if an exact name matches */

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

  1021 		{

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

  1023 			{

  1024 				continue;

  1025 			}

  1026 			if  (!pTarget->IsConnected())

  1027 			{

  1028 				continue;

  1029 			}

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

  1031 			{

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

  1033 					== COMMAND_TARGET_VALID)

  1034 				{

  1035 					info->targets[0] = i;

  1036 					info->num_targets = 1;

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

  1038 					info->target_name_style = COMMAND_TARGETNAME_RAW;

  1039 				}

  1040 				else

  1041 				{

  1042 					info->num_targets = 0;

  1043 				}

  1044 				return;

  1045 			}

  1046 		}

  1047 	}

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

  1050 	{

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

  1052 		info->num_targets = 1;

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

  1054 		info->target_name_style = COMMAND_TARGETNAME_RAW;

  1055 		return;

  1056 	}

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

  1059 	{

  1060 		bool is_multi = false;

  1061 		bool bots_only = false;

  1062 		int skip_client = -1;

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

  1065 		{

  1066 			is_multi = true;

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

  1068 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1069 		}

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

  1071 		{

  1072 			is_multi = true;

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

  1074 			{

  1075 				info->num_targets = 0;

  1076 				info->reason = COMMAND_TARGET_NOT_ALIVE;

  1077 				return;

  1078 			}

  1079 			info->flags |= COMMAND_FILTER_DEAD;

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

  1081 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1082 		}

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

  1084 		{

  1085 			is_multi = true;

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

  1087 			{

  1088 				info->num_targets = 0;

  1089 				info->reason = COMMAND_TARGET_NOT_DEAD;

  1090 				return;

  1091 			}

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

  1093 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1094 			info->flags |= COMMAND_FILTER_ALIVE;

  1095 		}

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

  1097 		{

  1098 			is_multi = true;

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

  1100 			{

  1101 				info->num_targets = 0;

  1102 				info->reason = COMMAND_FILTER_NO_BOTS;

  1103 				return;

  1104 			}

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

  1106 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1107 			bots_only = true;

  1108 		}

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

  1110 		{

  1111 			is_multi = true;

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

  1113 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1114 			info->flags |= COMMAND_FILTER_NO_BOTS;

  1115 		}

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

  1117 		{

  1118 			is_multi = true;

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

  1120 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1121 			skip_client = info->admin;

  1122 		}

  1124 		if (is_multi)

  1125 		{

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

  1127 			{

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

  1129 				{

  1130 					continue;

  1131 				}

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

  1133 				{

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

  1135 						&& skip_client != i)

  1136 					{

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

  1138 					}

  1139 				}

  1140 			}

  1142 			info->num_targets = total;

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

  1144 			return;

  1145 		}

  1146 	}

  1148 	List<ICommandTargetProcessor *>::iterator iter;

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

  1150 	{

  1151 		ICommandTargetProcessor *pProcessor = (*iter);

  1152 		if (pProcessor->ProcessCommandTarget(info))

  1153 		{

  1154 			return;

  1155 		}

  1156 	}

  1158 	/* Check partial names */

  1159 	int found_client = 0;

  1160 	CPlayer *pFoundClient = NULL;

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

  1162 	{

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

  1164 		{

  1165 			continue;

  1166 		}

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

  1169 		{

  1170 			if (found_client)

  1171 			{

  1172 				info->num_targets = 0;

  1173 				info->reason = COMMAND_TARGET_AMBIGUOUS;

  1174 				return;

  1175 			}

  1176 			else

  1177 			{

  1178 				found_client = i;

  1179 				pFoundClient = pTarget;

  1180 			}

  1181 		}

  1182 	}

  1184 	if (found_client)

  1185 	{

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

  1187 			== COMMAND_TARGET_VALID)

  1188 		{

  1189 			info->targets[0] = found_client;

  1190 			info->num_targets = 1;

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

  1192 			info->target_name_style = COMMAND_TARGETNAME_RAW;

  1193 		}

  1194 		else

  1195 		{

  1196 			info->num_targets = 0;

  1197 		}

  1198 	}

  1199 	else

  1200 	{

  1201 		info->num_targets = 0;

  1202 		info->reason = COMMAND_TARGET_NONE;

  1203 	}

  1204 }

  1206 /*******************

  1207  *** PLAYER CODE ***

  1208  *******************/

  1210 CPlayer::CPlayer()

  1211 {

  1212 	m_IsConnected = false;

  1213 	m_IsInGame = false;

  1214 	m_IsAuthorized = false;

  1215 	m_pEdict = NULL;

  1216 	m_Admin = INVALID_ADMIN_ID;

  1217 	m_TempAdmin = false;

  1218 	m_Info = NULL;

  1219 	m_bAdminCheckSignalled = false;

  1220 	m_bIsInKickQueue = false;

  1221 	m_LastPassword.clear();

  1222 	m_LangId = SOURCEMOD_LANGUAGE_ENGLISH;

  1223 	m_bFakeClient = false;

  1224 }

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

  1227 {

  1228 	m_IsConnected = true;

  1229 	m_Name.assign(name);

  1230 	m_Ip.assign(ip);

  1231 	m_pEdict = pEntity;

  1232 	m_iIndex = engine->IndexOfEdict(pEntity);

  1233 	m_LangId = g_Translator.GetServerLanguage();

  1235 	char ip2[24], *ptr;

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

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

  1238 	{

  1239 		*ptr = '\0';

  1240 	}

  1241 	m_IpNoPort.assign(ip2);

  1242 }

  1244 void CPlayer::Connect()

  1245 {

  1246 	if (m_IsInGame)

  1247 	{

  1248 		return;

  1249 	}

  1251 	m_IsInGame = true;

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

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

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

  1256 	{

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

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

  1259 	}

  1260 	else

  1261 	{

  1262 		m_LastPassword.assign("");

  1263 	}

  1264 }

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

  1267 {

  1268 	if (m_IsAuthorized)

  1269 	{

  1270 		return;

  1271 	}

  1273 	m_IsAuthorized = true;

  1274 	m_AuthID.assign(steamid);

  1275 }

  1277 void CPlayer::Disconnect()

  1278 {

  1279 	DumpAdmin(false);

  1280 	m_IsConnected = false;

  1281 	m_IsInGame = false;

  1282 	m_IsAuthorized = false;

  1283 	m_Name.clear();

  1284 	m_Ip.clear();

  1285 	m_AuthID.clear();

  1286 	m_pEdict = NULL;

  1287 	m_Info = NULL;

  1288 	m_bAdminCheckSignalled = false;

  1289 	m_UserId = -1;

  1290 	m_bIsInKickQueue = false;

  1291 	m_bFakeClient = false;

  1292 }

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

  1295 {

  1296 	m_Name.assign(name);

  1297 }

  1299 const char *CPlayer::GetName()

  1300 {

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

  1302 	{

  1303 		return m_Info->GetName();

  1304 	}

  1306 	return m_Name.c_str();

  1307 }

  1309 const char *CPlayer::GetIPAddress()

  1310 {

  1311 	return m_Ip.c_str();

  1312 }

  1314 const char *CPlayer::GetAuthString()

  1315 {

  1316 	return m_AuthID.c_str();

  1317 }

  1319 edict_t *CPlayer::GetEdict()

  1320 {

  1321 	return m_pEdict;

  1322 }

  1324 bool CPlayer::IsInGame()

  1325 {

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

  1327 }

  1329 bool CPlayer::WasCountedAsInGame()

  1330 {

  1331 	return m_IsInGame;

  1332 }

  1334 bool CPlayer::IsConnected()

  1335 {

  1336 	return m_IsConnected;

  1337 }

  1339 bool CPlayer::IsAuthorized()

  1340 {

  1341 	return m_IsAuthorized;

  1342 }

  1344 IPlayerInfo *CPlayer::GetPlayerInfo()

  1345 {

  1346 	if (m_pEdict->GetUnknown())

  1347 	{

  1348 		return m_Info;

  1349 	}

  1351 	return NULL;

  1352 }

  1354 bool CPlayer::IsFakeClient()

  1355 {

  1356 	return m_bFakeClient;

  1357 }

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

  1360 {

  1361 	if (!m_IsConnected)

  1362 	{

  1363 		return;

  1364 	}

  1366 	DumpAdmin(false);

  1368 	m_Admin = id;

  1369 	m_TempAdmin = temporary;

  1370 }

  1372 AdminId CPlayer::GetAdminId()

  1373 {

  1374 	return m_Admin;

  1375 }

  1377 void CPlayer::DumpAdmin(bool deleting)

  1378 {

  1379 	if (m_Admin != INVALID_ADMIN_ID)

  1380 	{

  1381 		if (m_TempAdmin && !deleting)

  1382 		{

  1383 			g_Admins.InvalidateAdmin(m_Admin);

  1384 		}

  1385 		m_Admin = INVALID_ADMIN_ID;

  1386 		m_TempAdmin = false;

  1387 	}

  1388 }

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

  1391 {

  1392 	MarkAsBeingKicked();

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

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

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

  1396 }

  1398 void CPlayer::Authorize_Post()

  1399 {

  1400 	if (m_IsInGame)

  1401 	{

  1402 		DoPostConnectAuthorization();

  1403 	}

  1404 }

  1406 void CPlayer::DoPostConnectAuthorization()

  1407 {

  1408 	bool delay = false;

  1410 	List<IClientListener *>::iterator iter;

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

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

  1413 		 iter++)

  1414 	{

  1415 		IClientListener *pListener = (*iter);

  1416 #if defined MIN_API_FOR_ADMINCALLS

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

  1418 		{

  1419 			continue;

  1420 		}

  1421 #endif

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

  1423 		{

  1424 			delay = true;

  1425 		}

  1426 	}

  1428 	cell_t result = 0;

  1429 	PreAdminCheck->PushCell(m_iIndex);

  1430 	PreAdminCheck->Execute(&result);

  1432 	/* Defer, for better or worse */

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

  1434 	{

  1435 		return;

  1436 	}

  1438 	/* Sanity check */

  1439 	if (!IsConnected())

  1440 	{

  1441 		return;

  1442 	}

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

  1445 	DoBasicAdminChecks();

  1447 	/* Send the notification out */

  1448 	NotifyPostAdminChecks();

  1449 }

  1451 bool CPlayer::RunAdminCacheChecks()

  1452 {

  1453 	AdminId old_id = GetAdminId();

  1455 	DoBasicAdminChecks();

  1457 	return (GetAdminId() != old_id);

  1458 }

  1460 void CPlayer::NotifyPostAdminChecks()

  1461 {

  1462 	if (m_bAdminCheckSignalled)

  1463 	{

  1464 		return;

  1465 	}

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

  1468 	m_bAdminCheckSignalled = true;

  1470 	List<IClientListener *>::iterator iter;

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

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

  1473 		iter++)

  1474 	{

  1475 		IClientListener *pListener = (*iter);

  1476 #if defined MIN_API_FOR_ADMINCALLS

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

  1478 		{

  1479 			continue;

  1480 		}

  1481 #endif

  1482 		pListener->OnClientPostAdminCheck(m_iIndex);

  1483 	}

  1485 	PostAdminFilter->PushCell(m_iIndex);

  1486 	PostAdminFilter->Execute(NULL);

  1488 	PostAdminCheck->PushCell(m_iIndex);

  1489 	PostAdminCheck->Execute(NULL);

  1490 }

  1492 void CPlayer::DoBasicAdminChecks()

  1493 {

  1494 	if (GetAdminId() != INVALID_ADMIN_ID)

  1495 	{

  1496 		return;

  1497 	}

  1499 	/* First check the name */

  1500 	AdminId id;

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

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

  1504 	{

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

  1506 		{

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

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

  1509 		}

  1510 		return;

  1511 	}

  1513 	/* Check IP */

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

  1515 	{

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

  1517 		{

  1518 			return;

  1519 		}

  1520 	}

  1522 	/* Check IP address */

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

  1524 	{

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

  1526 		{

  1527 			return;

  1528 		}

  1529 	}

  1530 }

  1532 unsigned int CPlayer::GetLanguageId()

  1533 {

  1534 	return m_LangId;

  1535 }

  1537 int CPlayer::GetUserId()

  1538 {

  1539 	if (m_UserId == -1)

  1540 	{

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

  1542 	}

  1544 	return m_UserId;

  1545 }

  1547 bool CPlayer::IsInKickQueue()

  1548 {

  1549 	return m_bIsInKickQueue;

  1550 }

  1552 void CPlayer::MarkAsBeingKicked()

  1553 {

  1554 	m_bIsInKickQueue = true;

  1555 }

  1557 int CPlayer::GetLifeState()

  1558 {

  1559 	if (lifestate_offset == -1)

  1560 	{

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

  1562 		{

  1563 			lifestate_offset = -2;

  1564 		}

  1565 	}

  1567 	if (lifestate_offset < 0)

  1568 	{

  1569 		IPlayerInfo *info = GetPlayerInfo();

  1570 		if (info == NULL)

  1571 		{

  1572 			return PLAYER_LIFE_UNKNOWN;

  1573 		}

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

  1575 	}

  1577 	if (m_pEdict == NULL)

  1578 	{

  1579 		return PLAYER_LIFE_UNKNOWN;

  1580 	}

  1582 	CBaseEntity *pEntity;

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

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

  1585 	{

  1586 		return PLAYER_LIFE_UNKNOWN;

  1587 	}

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

  1590 	{

  1591 		return PLAYER_LIFE_ALIVE;

  1592 	}

  1593 	else

  1594 	{

  1595 		return PLAYER_LIFE_DEAD;

  1596 	}

  1597 }

author	Scott Ehlert <ds@alliedmods.net>
	Sun Aug 24 04:35:48 2008 +0000 (2008-08-24)
changeset 2237	4403a982ec91
parent 2181	7c85684253ed
child 2289	44045ead61cd
permissions	-rw-r--r--