sourcemod-central: core/PlayerManager.cpp@f993e100e5a3

     1 /**

     2  * vim: set ts=4 :

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

     4  * SourceMod

     5  * Copyright (C) 2004-2007 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"

    50 PlayerManager g_Players;

    51 bool g_OnMapStarted = false;

    52 IForward *PreAdminCheck = NULL;

    53 IForward *PostAdminCheck = NULL;

    54 IForward *PostAdminFilter = NULL;

    55 const unsigned int *g_NumPlayersToAuth = NULL;

    56 int lifestate_offset = -1;

    57 List<ICommandTargetProcessor *> target_processors;

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

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

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

    62 #if defined ORANGEBOX_BUILD

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

    64 #else

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

    66 #endif

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

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

    70 class KickPlayerTimer : public ITimedEvent

    71 {

    72 public:

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

    74 	{

    75 		int userid = (int)pData;

    76 		int client = g_Players.GetClientOfUserId(userid);

    77 		if (client)

    78 		{

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

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

    81 		}

    82 		return Pl_Stop;

    83 	}

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

    85 	{

    86 	}

    87 } s_KickPlayerTimer;

    89 PlayerManager::PlayerManager()

    90 {

    91 	m_AuthQueue = NULL;

    92 	m_FirstPass = false;

    93 	m_maxClients = 0;

    95 	m_UserIdLookUp = new int[USHRT_MAX+1];

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

    97 }

    99 PlayerManager::~PlayerManager()

   100 {

   101 	g_NumPlayersToAuth = NULL;

   103 	delete [] m_AuthQueue;

   104 	delete [] m_UserIdLookUp;

   105 }

   107 void PlayerManager::OnSourceModAllInitialized()

   108 {

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

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

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

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

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

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

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

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

   118 	g_ShareSys.AddInterface(NULL, this);

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

   121 	ParamType p2[] = {Param_Cell};

   123 	m_clconnect = g_Forwards.CreateForward("OnClientConnect", ET_Event, 3, p1);

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

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

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

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

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

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

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

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

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

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

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

   136 }

   138 void PlayerManager::OnSourceModShutdown()

   139 {

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

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

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

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

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

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

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

   148 	/* Release forwards */

   149 	g_Forwards.ReleaseForward(m_clconnect);

   150 	g_Forwards.ReleaseForward(m_clputinserver);

   151 	g_Forwards.ReleaseForward(m_cldisconnect);

   152 	g_Forwards.ReleaseForward(m_cldisconnect_post);

   153 	g_Forwards.ReleaseForward(m_clcommand);

   154 	g_Forwards.ReleaseForward(m_clinfochanged);

   155 	g_Forwards.ReleaseForward(m_clauth);

   156 	g_Forwards.ReleaseForward(m_onActivate);

   157 	g_Forwards.ReleaseForward(m_onActivate2);

   159 	g_Forwards.ReleaseForward(PreAdminCheck);

   160 	g_Forwards.ReleaseForward(PostAdminCheck);

   161 	g_Forwards.ReleaseForward(PostAdminFilter);

   163 	delete [] m_Players;

   164 }

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

   167 												 const char *value,

   168 												 ConfigSource source,

   169 												 char *error,

   170 												 size_t maxlength)

   171 {

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

   173 	{

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

   175 		{

   176 			m_PassInfoVar.assign(value);

   177 		}

   178 		return ConfigResult_Accept;

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

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

   181 		{

   182 			m_QueryLang = true;

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

   184 			m_QueryLang = false;

   185 		} else {

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

   187 			return ConfigResult_Reject;

   188 		}

   189 		return ConfigResult_Accept;

   190 	}

   191 	return ConfigResult_Ignore;

   192 }

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

   195 {

   196 	if (!m_FirstPass)

   197 	{

   198 		/* Initialize all players */

   199 		m_maxClients = clientMax;

   200 		m_PlayerCount = 0;

   201 		m_Players = new CPlayer[m_maxClients + 1];

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

   203 		m_FirstPass = true;

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

   207 		g_NumPlayersToAuth = &m_AuthQueue[0];

   208 	}

   209 	m_onActivate->Execute(NULL);

   210 	m_onActivate2->Execute(NULL);

   212 	List<IClientListener *>::iterator iter;

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

   214 	{

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

   216 		{

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

   218 		}

   219 	}

   221 	g_OnMapStarted = true;

   223 	SM_ExecuteAllConfigs();

   224 }

   226 bool PlayerManager::IsServerActivated()

   227 {

   228 	return m_FirstPass;

   229 }

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

   232 {

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

   234 	if (password != NULL)

   235 	{

   236 		if (m_PassInfoVar.size() < 1)

   237 		{

   238 			return false;

   239 		}

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

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

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

   244 		{

   245 			return false;

   246 		}

   247 	}

   249 	pPlayer->SetAdminId(id, false);

   251 	return true;

   252 }

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

   255 {

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

   257 	if (password == NULL)

   258 	{

   259 		return false;

   260 	}

   262 	if (m_PassInfoVar.size() < 1)

   263 	{

   264 		return false;

   265 	}

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

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

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

   270 	{

   271 		return false;

   272 	}

   274 	pPlayer->SetAdminId(id, false);

   276 	return true;

   277 }

   279 void PlayerManager::RunAuthChecks()

   280 {

   281 	CPlayer *pPlayer;

   282 	const char *authstr;

   283 	unsigned int removed = 0;

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

   285 	{

   286 		pPlayer = GetPlayerByIndex(m_AuthQueue[i]);

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

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

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

   290 		{

   291 			/* Set authorization */

   292 			pPlayer->Authorize(authstr);

   294 			/* Mark as removed from queue */

   295 			unsigned int client = m_AuthQueue[i];

   296 			m_AuthQueue[i] = 0;

   297 			removed++;

   299 			/* Send to extensions */

   300 			List<IClientListener *>::iterator iter;

   301 			IClientListener *pListener;

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

   303 			{

   304 				pListener = (*iter);

   305 				pListener->OnClientAuthorized(client, authstr);

   306 				if (!pPlayer->IsConnected())

   307 				{

   308 					break;

   309 				}

   310 			}

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

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

   314 			{

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

   316 				m_clauth->PushCell(client);

   317 				m_clauth->PushString(authstr);

   318 				m_clauth->Execute(NULL);

   319 			}

   321 			if (pPlayer->IsConnected())

   322 			{

   323 				pPlayer->Authorize_Post();

   324 			}

   325 		}

   326 	}

   328 	/* Clean up the queue */

   329 	if (removed)

   330 	{

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

   332 		if (removed != m_AuthQueue[0])

   333 		{

   334 			unsigned int diff = 0;

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

   336 			{

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

   338 				if (m_AuthQueue[i] == 0)

   339 				{

   340 					/* Increase the differential */

   341 					diff++;

   342 				} else {

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

   344 					assert(i > diff);

   345 					assert(i - diff >= 1);

   346 					/* move this index down */

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

   348 				}

   349 			}

   350 			m_AuthQueue[0] -= removed;

   351 		} else {

   352 			m_AuthQueue[0] = 0;

   353 		}

   354 	}

   355 }

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

   358 {

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

   361 	List<IClientListener *>::iterator iter;

   362 	IClientListener *pListener = NULL;

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

   364 	{

   365 		pListener = (*iter);

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

   367 		{

   368 			return false;

   369 		}

   370 	}

   372 	cell_t res = 1;

   374 	m_Players[client].Initialize(pszName, pszAddress, pEntity);

   375 	m_clconnect->PushCell(client);

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

   377 	m_clconnect->PushCell(maxrejectlen);

   378 	m_clconnect->Execute(&res, NULL);

   380 	if (res)

   381 	{

   382 		if (!m_Players[client].IsAuthorized())

   383 		{

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

   385 		}

   386 	} else {

   387 		RETURN_META_VALUE(MRES_SUPERCEDE, false);

   388 	}

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

   392 	return true;

   393 }

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

   396 {

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

   398 	bool orig_value = META_RESULT_ORIG_RET(bool);

   399 	CPlayer *pPlayer = GetPlayerByIndex(client);

   401 	if (orig_value)

   402 	{

   403 		List<IClientListener *>::iterator iter;

   404 		IClientListener *pListener = NULL;

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

   406 		{

   407 			pListener = (*iter);

   408 			pListener->OnClientConnected(client);

   409 			if (!pPlayer->IsConnected())

   410 			{

   411 				break;

   412 			}

   413 		}

   414 	}

   416 	return true;

   417 }

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

   420 {

   421 	cell_t res;

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

   424 	CPlayer *pPlayer = GetPlayerByIndex(client);

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

   426 	if (!pPlayer->IsConnected())

   427 	{

   428 		/* Run manual connection routines */

   429 		char error[255];

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

   431 		pPlayer->Authorize(authid);

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

   433 		{

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

   435 			return;

   436 		}

   437 		List<IClientListener *>::iterator iter;

   438 		IClientListener *pListener = NULL;

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

   440 		{

   441 			pListener = (*iter);

   442 			pListener->OnClientConnected(client);

   443 			/* See if bot was kicked */

   444 			if (!pPlayer->IsConnected())

   445 			{

   446 				return;

   447 			}

   448 		}

   449 		/* Now do authorization */

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

   451 		{

   452 			pListener = (*iter);

   453 			pListener->OnClientAuthorized(client, authid);

   454 		}

   455 		/* Finally, tell plugins */

   456 		if (m_clauth->GetFunctionCount())

   457 		{

   458 			m_clauth->PushCell(client);

   459 			m_clauth->PushString(authid);

   460 			m_clauth->Execute(NULL);

   461 		}

   462 		pPlayer->Authorize_Post();

   463 	}

   465 	if (playerinfo)

   466 	{

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

   468 	}

   470 	/* Get the client's language */

   471 	if (m_QueryLang)

   472 	{

   473 		const char *name;

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

   475 		{

   476 			unsigned int langid;

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

   478 		} else {

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

   480 		}

   481 	}

   483 	m_Players[client].Connect();

   484 	m_PlayerCount++;

   486 	List<IClientListener *>::iterator iter;

   487 	IClientListener *pListener = NULL;

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

   489 	{

   490 		pListener = (*iter);

   491 		pListener->OnClientPutInServer(client);

   492 	}

   494 	m_clputinserver->PushCell(client);

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

   497 	if (m_Players[client].IsAuthorized())

   498 	{

   499 		m_Players[client].DoPostConnectAuthorization();

   500 	}

   501 }

   503 void PlayerManager::OnSourceModLevelEnd()

   504 {

   505 	/* Disconnect all bots still in game */

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

   507 	{

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

   509 		{

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

   511 		}

   512 	}

   513 	m_PlayerCount = 0;

   514 }

   516 void PlayerManager::OnClientDisconnect(edict_t *pEntity)

   517 {

   518 	cell_t res;

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

   521 	if (m_Players[client].IsConnected())

   522 	{

   523 		m_cldisconnect->PushCell(client);

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

   525 	} else {

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

   527 		return;

   528 	}

   530 	if (m_Players[client].WasCountedAsInGame())

   531 	{

   532 		m_PlayerCount--;

   533 	}

   535 	List<IClientListener *>::iterator iter;

   536 	IClientListener *pListener = NULL;

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

   538 	{

   539 		pListener = (*iter);

   540 		pListener->OnClientDisconnecting(client);

   541 	}

   543 	/**

   544 	 * Remove client from auth queue if necessary

   545 	 */

   546 	if (!m_Players[client].IsAuthorized())

   547 	{

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

   549 		{

   550 			if (m_AuthQueue[i] == (unsigned)client)

   551 			{

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

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

   554 				{

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

   556 				}

   557 				/* Remove us and break */

   558 				m_AuthQueue[0]--;

   559 				break;

   560 			}

   561 		}

   562 	}

   564 	m_Players[client].Disconnect();

   565 	m_UserIdLookUp[engine->GetPlayerUserId(pEntity)] = 0;

   566 }

   568 void PlayerManager::OnClientDisconnect_Post(edict_t *pEntity)

   569 {

   570 	cell_t res;

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

   573 	m_cldisconnect_post->PushCell(client);

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

   576 	List<IClientListener *>::iterator iter;

   577 	IClientListener *pListener = NULL;

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

   579 	{

   580 		pListener = (*iter);

   581 		pListener->OnClientDisconnected(client);

   582 	}

   583 }

   585 #if defined ORANGEBOX_BUILD

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

   587 {

   588 #else

   589 void PlayerManager::OnClientCommand(edict_t *pEntity)

   590 {

   591 	CCommand args;

   592 #endif

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

   594 	cell_t res = Pl_Continue;

   596 	CPlayer *pPlayer = GetPlayerByIndex(client);

   597 	if (!pPlayer || !pPlayer->IsConnected())

   598 	{

   599 		return;

   600 	}

   602 	g_HL2.PushCommandStack(&args);

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

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

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

   608 	if (result)

   609 	{

   610 		res = Pl_Handled;

   611 	} else {

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

   613 		if (result)

   614 		{

   615 			res = Pl_Handled;

   616 		}

   617 	}

   619 	cell_t res2 = Pl_Continue;

   620 	m_clcommand->PushCell(client);

   621 	m_clcommand->PushCell(argcount);

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

   624 	if (res2 > res)

   625 	{

   626 		res = res2;

   627 	}

   629 	if (res >= Pl_Stop)

   630 	{

   631 		g_HL2.PopCommandStack();

   632 		RETURN_META(MRES_SUPERCEDE);

   633 	}

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

   637 	g_HL2.PopCommandStack();

   639 	if (res >= Pl_Handled)

   640 	{

   641 		RETURN_META(MRES_SUPERCEDE);

   642 	}

   643 }

   645 void PlayerManager::OnClientSettingsChanged(edict_t *pEntity)

   646 {

   647 	cell_t res;

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

   650 	if (!m_Players[client].IsConnected())

   651 	{

   652 		return;

   653 	}

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

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

   658 	IPlayerInfo *info = m_Players[client].GetPlayerInfo();

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

   660 	const char *old_name = m_Players[client].m_Name.c_str();

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

   663 	{

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

   665 		if (id != INVALID_ADMIN_ID && m_Players[client].GetAdminId() != id)

   666 		{

   667 			if (!CheckSetAdminName(client, &m_Players[client], id))

   668 			{

   669 				m_Players[client].Kick("Your name is reserved by SourceMod; set your password to use it.");

   670 				RETURN_META(MRES_IGNORED);

   671 			}

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

   673 			if (id == m_Players[client].GetAdminId())

   674 			{

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

   676 				m_Players[client].SetAdminId(INVALID_ADMIN_ID, false);

   677 			}

   678 		}

   679 		m_Players[client].SetName(new_name);

   680 	}

   682 	if (m_PassInfoVar.size() > 0)

   683 	{

   684 		/* Try for a password change */

   685 		const char *old_pass = m_Players[client].m_LastPassword.c_str();

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

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

   688 		{

   689 			m_Players[client].m_LastPassword.assign(new_pass);

   690 			if (m_Players[client].IsInGame() && m_Players[client].IsAuthorized())

   691 			{

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

   693 				m_Players[client].DoBasicAdminChecks();

   694 			}

   695 		}

   696 	}

   697 }

   699 int PlayerManager::GetMaxClients()

   700 {

   701 	return m_maxClients;

   702 }

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

   705 {

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

   707 	{

   708 		return NULL;

   709 	}

   710 	return &m_Players[client];

   711 }

   713 int PlayerManager::GetNumPlayers()

   714 {

   715 	return m_PlayerCount;

   716 }

   718 int PlayerManager::GetClientOfUserId(int userid)

   719 {

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

   721 	{

   722 		return 0;

   723 	}

   725 	int client = m_UserIdLookUp[userid];

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

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

   729 	 * check before invoking this backwards compat code.

   730 	 */

   731 	if (client)

   732 	{

   733 		CPlayer *player = GetPlayerByIndex(client);

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

   735 		{

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

   737 			if (realUserId == userid)

   738 			{

   739 				return client;

   740 			}

   741 		}

   742 	}

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

   745 	CPlayer *player;

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

   747 	{

   748 		player = GetPlayerByIndex(i);

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

   750 		{

   751 			continue;

   752 		}

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

   754 		{

   755 			m_UserIdLookUp[userid] = i;

   756 			return i;

   757 		}

   758 	}

   760 	return 0;

   761 }

   763 void PlayerManager::AddClientListener(IClientListener *listener)

   764 {

   765 	m_hooks.push_back(listener);

   766 }

   768 void PlayerManager::RemoveClientListener(IClientListener *listener)

   769 {

   770 	m_hooks.remove(listener);

   771 }

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

   774 {

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

   776 	return GetGamePlayer(index);

   777 }

   779 IGamePlayer *PlayerManager::GetGamePlayer(int client)

   780 {

   781 	return GetPlayerByIndex(client);

   782 }

   784 void PlayerManager::ClearAdminId(AdminId id)

   785 {

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

   787 	{

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

   789 		{

   790 			m_Players[i].DumpAdmin(true);

   791 		}

   792 	}

   793 }

   795 void PlayerManager::ClearAllAdmins()

   796 {

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

   798 	{

   799 		m_Players[i].DumpAdmin(true);

   800 	}

   801 }

   803 const char *PlayerManager::GetPassInfoVar()

   804 {

   805 	return m_PassInfoVar.c_str();

   806 }

   808 void PlayerManager::RecheckAnyAdmins()

   809 {

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

   811 	{

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

   813 		{

   814 			m_Players[i].DoBasicAdminChecks();

   815 		}

   816 	}

   817 }

   819 unsigned int PlayerManager::GetReplyTo()

   820 {

   821 	return g_ChatTriggers.GetReplyTo();

   822 }

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

   825 {

   826 	return g_ChatTriggers.SetReplyTo(reply);

   827 }

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

   830 {

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

   832 }

   834 void PlayerManager::RegisterCommandTargetProcessor(ICommandTargetProcessor *pHandler)

   835 {

   836 	target_processors.push_back(pHandler);

   837 }

   839 void PlayerManager::UnregisterCommandTargetProcessor(ICommandTargetProcessor *pHandler)

   840 {

   841 	target_processors.remove(pHandler);

   842 }

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

   845 {

   846 	if ((flags & COMMAND_FILTER_CONNECTED) == COMMAND_FILTER_CONNECTED

   847 		&& !pTarget->IsConnected())

   848 	{

   849 		return COMMAND_TARGET_NONE;

   850 	}

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

   852 		!pTarget->IsInGame())

   853 	{

   854 		return COMMAND_TARGET_NOT_IN_GAME;

   855 	}

   857 	if ((flags & COMMAND_FILTER_NO_BOTS) == COMMAND_FILTER_NO_BOTS

   858 		&& pTarget->IsFakeClient())

   859 	{

   860 		return COMMAND_TARGET_NOT_HUMAN;

   861 	}

   863 	if (pAdmin != NULL)

   864 	{

   865 		if ((flags & COMMAND_FILTER_NO_IMMUNITY) != COMMAND_FILTER_NO_IMMUNITY

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

   867 		{

   868 			return COMMAND_TARGET_IMMUNE;

   869 		}

   870 	}

   872 	if ((flags & COMMAND_FILTER_ALIVE) == COMMAND_FILTER_ALIVE

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

   874 	{

   875 		return COMMAND_TARGET_NOT_ALIVE;

   876 	}

   878 	if ((flags & COMMAND_FILTER_DEAD) == COMMAND_FILTER_DEAD

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

   880 	{

   881 		return COMMAND_TARGET_NOT_DEAD;

   882 	}

   884 	return COMMAND_TARGET_VALID;

   885 }

   887 void PlayerManager::ProcessCommandTarget(cmd_target_info_t *info)

   888 {

   889 	CPlayer *pTarget, *pAdmin;

   890 	int max_clients, total = 0;

   892 	max_clients = GetMaxClients();

   894 	if (info->max_targets < 1)

   895 	{

   896 		info->reason = COMMAND_TARGET_NONE;

   897 		info->num_targets = 0;

   898 	}

   900 	if (info->admin == 0)

   901 	{

   902 		pAdmin = NULL;

   903 	}

   904 	else

   905 	{

   906 		pAdmin = GetPlayerByIndex(info->admin);

   907 	}

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

   910 	{

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

   912 		int client = GetClientOfUserId(userid);

   914 		/* See if a valid userid matched */

   915 		if (client > 0)

   916 		{

   917 			IGamePlayer *pTarget = GetPlayerByIndex(client);

   918 			if (pTarget != NULL)

   919 			{

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

   921 				{

   922 					info->targets[0] = client;

   923 					info->num_targets = 1;

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

   925 					info->target_name_style = COMMAND_TARGETNAME_RAW;

   926 				}

   927 				else

   928 				{

   929 					info->num_targets = 0;

   930 				}

   931 				return;

   932 			}

   933 		}

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

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

   937 		{

   938 			size_t p, len;

   939 			char new_pattern[256];

   941 			strcpy(new_pattern, "STEAM_");

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

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

   944 			{

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

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

   947 				{

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

   949 				}

   950 			}

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

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

   954 			{

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

   956 				{

   957 					continue;

   958 				}

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

   960 				{

   961 					continue;

   962 				}

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

   964 				{

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

   966 						== COMMAND_TARGET_VALID)

   967 					{

   968 						info->targets[0] = i;

   969 						info->num_targets = 1;

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

   971 						info->target_name_style = COMMAND_TARGETNAME_RAW;

   972 					}

   973 					else

   974 					{

   975 						info->num_targets = 0;

   976 					}

   977 					return;

   978 				}

   979 			}

   980 		}

   982 		/* See if an exact name matches */

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

   984 		{

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

   986 			{

   987 				continue;

   988 			}

   989 			if  (!pTarget->IsConnected())

   990 			{

   991 				continue;

   992 			}

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

   994 			{

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

   996 					== COMMAND_TARGET_VALID)

   997 				{

   998 					info->targets[0] = i;

   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 		}

  1010 	}

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

  1013 	{

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

  1015 		info->num_targets = 1;

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

  1017 		info->target_name_style = COMMAND_TARGETNAME_RAW;

  1018 		return;

  1019 	}

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

  1022 	{

  1023 		bool is_multi = false;

  1024 		bool bots_only = false;

  1025 		int skip_client = -1;

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

  1028 		{

  1029 			is_multi = true;

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

  1031 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1032 		}

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

  1034 		{

  1035 			is_multi = true;

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

  1037 			{

  1038 				info->num_targets = 0;

  1039 				info->reason = COMMAND_TARGET_NOT_ALIVE;

  1040 				return;

  1041 			}

  1042 			info->flags |= COMMAND_FILTER_DEAD;

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

  1044 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1045 		}

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

  1047 		{

  1048 			is_multi = true;

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

  1050 			{

  1051 				info->num_targets = 0;

  1052 				info->reason = COMMAND_TARGET_NOT_DEAD;

  1053 				return;

  1054 			}

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

  1056 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1057 			info->flags |= COMMAND_FILTER_ALIVE;

  1058 		}

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

  1060 		{

  1061 			is_multi = true;

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

  1063 			{

  1064 				info->num_targets = 0;

  1065 				info->reason = COMMAND_FILTER_NO_BOTS;

  1066 				return;

  1067 			}

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

  1069 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1070 			bots_only = true;

  1071 		}

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

  1073 		{

  1074 			is_multi = true;

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

  1076 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1077 			info->flags |= COMMAND_FILTER_NO_BOTS;

  1078 		}

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

  1080 		{

  1081 			is_multi = true;

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

  1083 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1084 			skip_client = info->admin;

  1085 		}

  1087 		if (is_multi)

  1088 		{

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

  1090 			{

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

  1092 				{

  1093 					continue;

  1094 				}

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

  1096 				{

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

  1098 						&& skip_client != i)

  1099 					{

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

  1101 					}

  1102 				}

  1103 			}

  1105 			info->num_targets = total;

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

  1107 			return;

  1108 		}

  1109 	}

  1111 	List<ICommandTargetProcessor *>::iterator iter;

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

  1113 	{

  1114 		ICommandTargetProcessor *pProcessor = (*iter);

  1115 		if (pProcessor->ProcessCommandTarget(info))

  1116 		{

  1117 			return;

  1118 		}

  1119 	}

  1121 	/* Check partial names */

  1122 	int found_client = 0;

  1123 	CPlayer *pFoundClient = NULL;

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

  1125 	{

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

  1127 		{

  1128 			continue;

  1129 		}

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

  1132 		{

  1133 			if (found_client)

  1134 			{

  1135 				info->num_targets = 0;

  1136 				info->reason = COMMAND_TARGET_AMBIGUOUS;

  1137 				return;

  1138 			}

  1139 			else

  1140 			{

  1141 				found_client = i;

  1142 				pFoundClient = pTarget;

  1143 			}

  1144 		}

  1145 	}

  1147 	if (found_client)

  1148 	{

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

  1150 			== COMMAND_TARGET_VALID)

  1151 		{

  1152 			info->targets[0] = found_client;

  1153 			info->num_targets = 1;

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

  1155 			info->target_name_style = COMMAND_TARGETNAME_RAW;

  1156 		}

  1157 		else

  1158 		{

  1159 			info->num_targets = 0;

  1160 		}

  1161 	}

  1162 	else

  1163 	{

  1164 		info->num_targets = 0;

  1165 		info->reason = COMMAND_TARGET_NONE;

  1166 	}

  1167 }

  1169 /*******************

  1170  *** PLAYER CODE ***

  1171  *******************/

  1173 CPlayer::CPlayer()

  1174 {

  1175 	m_IsConnected = false;

  1176 	m_IsInGame = false;

  1177 	m_IsAuthorized = false;

  1178 	m_pEdict = NULL;

  1179 	m_Admin = INVALID_ADMIN_ID;

  1180 	m_TempAdmin = false;

  1181 	m_Info = NULL;

  1182 	m_bAdminCheckSignalled = false;

  1183 	m_bIsInKickQueue = false;

  1184 	m_LastPassword.clear();

  1185 	m_LangId = LANGUAGE_ENGLISH;

  1186 }

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

  1189 {

  1190 	m_IsConnected = true;

  1191 	m_Name.assign(name);

  1192 	m_Ip.assign(ip);

  1193 	m_pEdict = pEntity;

  1194 	m_iIndex = engine->IndexOfEdict(pEntity);

  1195 	m_LangId = g_Translator.GetServerLanguage();

  1197 	char ip2[24], *ptr;

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

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

  1200 	{

  1201 		*ptr = '\0';

  1202 	}

  1203 	m_IpNoPort.assign(ip2);

  1204 }

  1206 void CPlayer::Connect()

  1207 {

  1208 	if (m_IsInGame)

  1209 	{

  1210 		return;

  1211 	}

  1213 	m_IsInGame = true;

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

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

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

  1218 	{

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

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

  1221 	}

  1222 	else

  1223 	{

  1224 		m_LastPassword.assign("");

  1225 	}

  1226 }

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

  1229 {

  1230 	if (m_IsAuthorized)

  1231 	{

  1232 		return;

  1233 	}

  1235 	m_IsAuthorized = true;

  1236 	m_AuthID.assign(steamid);

  1237 }

  1239 void CPlayer::Disconnect()

  1240 {

  1241 	DumpAdmin(false);

  1242 	m_IsConnected = false;

  1243 	m_IsInGame = false;

  1244 	m_IsAuthorized = false;

  1245 	m_Name.clear();

  1246 	m_Ip.clear();

  1247 	m_AuthID.clear();

  1248 	m_pEdict = NULL;

  1249 	m_Info = NULL;

  1250 	m_bAdminCheckSignalled = false;

  1251 	m_UserId = -1;

  1252 	m_bIsInKickQueue = false;

  1253 }

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

  1256 {

  1257 	m_Name.assign(name);

  1258 }

  1260 const char *CPlayer::GetName()

  1261 {

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

  1263 	{

  1264 		return m_Info->GetName();

  1265 	}

  1267 	return m_Name.c_str();

  1268 }

  1270 const char *CPlayer::GetIPAddress()

  1271 {

  1272 	return m_Ip.c_str();

  1273 }

  1275 const char *CPlayer::GetAuthString()

  1276 {

  1277 	return m_AuthID.c_str();

  1278 }

  1280 edict_t *CPlayer::GetEdict()

  1281 {

  1282 	return m_pEdict;

  1283 }

  1285 bool CPlayer::IsInGame()

  1286 {

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

  1288 }

  1290 bool CPlayer::WasCountedAsInGame()

  1291 {

  1292 	return m_IsInGame;

  1293 }

  1295 bool CPlayer::IsConnected()

  1296 {

  1297 	return m_IsConnected;

  1298 }

  1300 bool CPlayer::IsAuthorized()

  1301 {

  1302 	return m_IsAuthorized;

  1303 }

  1305 IPlayerInfo *CPlayer::GetPlayerInfo()

  1306 {

  1307 	if (m_pEdict->GetUnknown())

  1308 	{

  1309 		return m_Info;

  1310 	}

  1312 	return NULL;

  1313 }

  1315 bool CPlayer::IsFakeClient()

  1316 {

  1317 	return (strcmp(m_AuthID.c_str(), "BOT") == 0);

  1318 }

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

  1321 {

  1322 	if (!m_IsConnected)

  1323 	{

  1324 		return;

  1325 	}

  1327 	DumpAdmin(false);

  1329 	m_Admin = id;

  1330 	m_TempAdmin = temporary;

  1331 }

  1333 AdminId CPlayer::GetAdminId()

  1334 {

  1335 	return m_Admin;

  1336 }

  1338 void CPlayer::DumpAdmin(bool deleting)

  1339 {

  1340 	if (m_Admin != INVALID_ADMIN_ID)

  1341 	{

  1342 		if (m_TempAdmin && !deleting)

  1343 		{

  1344 			g_Admins.InvalidateAdmin(m_Admin);

  1345 		}

  1346 		m_Admin = INVALID_ADMIN_ID;

  1347 		m_TempAdmin = false;

  1348 	}

  1349 }

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

  1352 {

  1353 	MarkAsBeingKicked();

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

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

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

  1357 }

  1359 void CPlayer::Authorize_Post()

  1360 {

  1361 	if (m_IsInGame)

  1362 	{

  1363 		DoPostConnectAuthorization();

  1364 	}

  1365 }

  1367 void CPlayer::DoPostConnectAuthorization()

  1368 {

  1369 	bool delay = false;

  1371 	List<IClientListener *>::iterator iter;

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

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

  1374 		 iter++)

  1375 	{

  1376 		IClientListener *pListener = (*iter);

  1377 #if defined MIN_API_FOR_ADMINCALLS

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

  1379 		{

  1380 			continue;

  1381 		}

  1382 #endif

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

  1384 		{

  1385 			delay = true;

  1386 		}

  1387 	}

  1389 	cell_t result = 0;

  1390 	PreAdminCheck->PushCell(m_iIndex);

  1391 	PreAdminCheck->Execute(&result);

  1393 	/* Defer, for better or worse */

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

  1395 	{

  1396 		return;

  1397 	}

  1399 	/* Sanity check */

  1400 	if (!IsConnected())

  1401 	{

  1402 		return;

  1403 	}

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

  1406 	DoBasicAdminChecks();

  1408 	/* Send the notification out */

  1409 	NotifyPostAdminChecks();

  1410 }

  1412 bool CPlayer::RunAdminCacheChecks()

  1413 {

  1414 	AdminId old_id = GetAdminId();

  1416 	DoBasicAdminChecks();

  1418 	return (GetAdminId() != old_id);

  1419 }

  1421 void CPlayer::NotifyPostAdminChecks()

  1422 {

  1423 	if (m_bAdminCheckSignalled)

  1424 	{

  1425 		return;

  1426 	}

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

  1429 	m_bAdminCheckSignalled = true;

  1431 	List<IClientListener *>::iterator iter;

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

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

  1434 		iter++)

  1435 	{

  1436 		IClientListener *pListener = (*iter);

  1437 #if defined MIN_API_FOR_ADMINCALLS

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

  1439 		{

  1440 			continue;

  1441 		}

  1442 #endif

  1443 		pListener->OnClientPostAdminCheck(m_iIndex);

  1444 	}

  1446 	PostAdminFilter->PushCell(m_iIndex);

  1447 	PostAdminFilter->Execute(NULL);

  1449 	PostAdminCheck->PushCell(m_iIndex);

  1450 	PostAdminCheck->Execute(NULL);

  1451 }

  1453 void CPlayer::DoBasicAdminChecks()

  1454 {

  1455 	if (GetAdminId() != INVALID_ADMIN_ID)

  1456 	{

  1457 		return;

  1458 	}

  1460 	/* First check the name */

  1461 	AdminId id;

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

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

  1465 	{

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

  1467 		{

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

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

  1470 		}

  1471 		return;

  1472 	}

  1474 	/* Check IP */

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

  1476 	{

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

  1478 		{

  1479 			return;

  1480 		}

  1481 	}

  1483 	/* Check IP address */

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

  1485 	{

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

  1487 		{

  1488 			return;

  1489 		}

  1490 	}

  1491 }

  1493 unsigned int CPlayer::GetLanguageId()

  1494 {

  1495 	return m_LangId;

  1496 }

  1498 int CPlayer::GetUserId()

  1499 {

  1500 	if (m_UserId == -1)

  1501 	{

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

  1503 	}

  1505 	return m_UserId;

  1506 }

  1508 bool CPlayer::IsInKickQueue()

  1509 {

  1510 	return m_bIsInKickQueue;

  1511 }

  1513 void CPlayer::MarkAsBeingKicked()

  1514 {

  1515 	m_bIsInKickQueue = true;

  1516 }

  1518 int CPlayer::GetLifeState()

  1519 {

  1520 	if (lifestate_offset == -1)

  1521 	{

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

  1523 		{

  1524 			lifestate_offset = -2;

  1525 		}

  1526 	}

  1528 	if (lifestate_offset < 0)

  1529 	{

  1530 		IPlayerInfo *info = GetPlayerInfo();

  1531 		if (info == NULL)

  1532 		{

  1533 			return PLAYER_LIFE_UNKNOWN;

  1534 		}

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

  1536 	}

  1538 	if (m_pEdict == NULL)

  1539 	{

  1540 		return PLAYER_LIFE_UNKNOWN;

  1541 	}

  1543 	CBaseEntity *pEntity;

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

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

  1546 	{

  1547 		return PLAYER_LIFE_UNKNOWN;

  1548 	}

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

  1551 	{

  1552 		return PLAYER_LIFE_ALIVE;

  1553 	}

  1554 	else

  1555 	{

  1556 		return PLAYER_LIFE_DEAD;

  1557 	}

  1558 }

author	Matt Woodrow <pred@alliedmods.net>
	Tue Mar 11 23:52:56 2008 +0000 (2008-03-11)
changeset 1921	f993e100e5a3
parent 1915	ab031366cfd1
child 1947	e73a1e51833b
permissions	-rw-r--r--