Home - sourcemod-central - file revision - core/PlayerManager.cpp@f34a4aae1483 Mercurial
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
core/PlayerManager.cpp
author David Anderson <dvander@alliedmods.net>
Wed May 02 19:14:26 2007 +0000 (2007-05-02)
changeset 719 f34a4aae1483
parent 717 6f9b8bab7ae8
child 720 893a8c83aee3
permissions -rw-r--r--
fixed issue amb235 
     1 /**
     2  * vim: set ts=4 :
     3  * ===============================================================
     4  * SourceMod (C)2004-2007 AlliedModders LLC.  All rights reserved.
     5  * ===============================================================
     6  *
     7  * This file is not open source and may not be copied without explicit
     8  * written permission of AlliedModders LLC.  This file may not be redistributed 
     9  * in whole or significant part.
    10  * For information, see LICENSE.txt or http://www.sourcemod.net/license.php
    11  *
    12  * Version: $Id$
    13  */
    14 
    15 #include "PlayerManager.h"
    16 #include "ForwardSys.h"
    17 #include "ShareSys.h"
    18 #include "AdminCache.h"
    19 #include "ConCmdManager.h"
    20 
    21 PlayerManager g_Players;
    22 
    23 SH_DECL_HOOK5(IServerGameClients, ClientConnect, SH_NOATTRIB, 0, bool, edict_t *, const char *, const char *, char *, int);
    24 SH_DECL_HOOK2_void(IServerGameClients, ClientPutInServer, SH_NOATTRIB, 0, edict_t *, const char *);
    25 SH_DECL_HOOK1_void(IServerGameClients, ClientDisconnect, SH_NOATTRIB, 0, edict_t *);
    26 SH_DECL_HOOK1_void(IServerGameClients, ClientCommand, SH_NOATTRIB, 0, edict_t *);
    27 SH_DECL_HOOK1_void(IServerGameClients, ClientSettingsChanged, SH_NOATTRIB, 0, edict_t *);
    28 SH_DECL_HOOK3_void(IServerGameDLL, ServerActivate, SH_NOATTRIB, 0, edict_t *, int, int);
    29 
    30 PlayerManager::PlayerManager()
    31 {
    32 	m_AuthQueue = NULL;
    33 	m_FirstPass = true;
    34 
    35 	m_UserIdLookUp = new int[USHRT_MAX];
    36 	memset(m_UserIdLookUp, 0, sizeof(int) * USHRT_MAX);
    37 }
    38 
    39 PlayerManager::~PlayerManager()
    40 {
    41 	delete [] m_AuthQueue;
    42 	delete [] m_UserIdLookUp;
    43 }
    44 
    45 void PlayerManager::OnSourceModAllInitialized()
    46 {
    47 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect, false);
    48 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect_Post, true);
    49 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientPutInServer, serverClients, this, &PlayerManager::OnClientPutInServer, true);
    50 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect, false);
    51 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect_Post, true);
    52 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientCommand, serverClients, this, &PlayerManager::OnClientCommand, false);
    53 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientSettingsChanged, serverClients, this, &PlayerManager::OnClientSettingsChanged, true);
    54 	SH_ADD_HOOK_MEMFUNC(IServerGameDLL, ServerActivate, gamedll, this, &PlayerManager::OnServerActivate, true);
    55 
    56 	g_ShareSys.AddInterface(NULL, this);
    57 
    58 	ParamType p1[] = {Param_Cell, Param_String, Param_Cell};
    59 	ParamType p2[] = {Param_Cell};
    60 
    61 	m_clconnect = g_Forwards.CreateForward("OnClientConnect", ET_Event, 3, p1);
    62 	m_clputinserver = g_Forwards.CreateForward("OnClientPutInServer", ET_Ignore, 1, p2);
    63 	m_cldisconnect = g_Forwards.CreateForward("OnClientDisconnect", ET_Ignore, 1, p2);
    64 	m_cldisconnect_post = g_Forwards.CreateForward("OnClientDisconnect_Post", ET_Ignore, 1, p2);
    65 	m_clcommand = g_Forwards.CreateForward("OnClientCommand", ET_Hook, 2, NULL, Param_Cell, Param_Cell);
    66 	m_clinfochanged = g_Forwards.CreateForward("OnClientSettingsChanged", ET_Ignore, 1, p2);
    67 	m_clauth = g_Forwards.CreateForward("OnClientAuthorized", ET_Ignore, 2, NULL, Param_Cell, Param_String);
    68 	m_onActivate = g_Forwards.CreateForward("OnServerLoad", ET_Ignore, 0, NULL);
    69 	m_onActivate2 = g_Forwards.CreateForward("OnMapStart", ET_Ignore, 0, NULL);
    70 }
    71 
    72 void PlayerManager::OnSourceModShutdown()
    73 {
    74 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect, false);
    75 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientPutInServer, serverClients, this, &PlayerManager::OnClientPutInServer, true);
    76 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect, false);
    77 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect_Post, true);
    78 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientCommand, serverClients, this, &PlayerManager::OnClientCommand, false);
    79 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientSettingsChanged, serverClients, this, &PlayerManager::OnClientSettingsChanged, true);
    80 	SH_REMOVE_HOOK_MEMFUNC(IServerGameDLL, ServerActivate, gamedll, this, &PlayerManager::OnServerActivate, true);
    81 
    82 	/* Release forwards */
    83 	g_Forwards.ReleaseForward(m_clconnect);
    84 	g_Forwards.ReleaseForward(m_clputinserver);
    85 	g_Forwards.ReleaseForward(m_cldisconnect);
    86 	g_Forwards.ReleaseForward(m_cldisconnect_post);
    87 	g_Forwards.ReleaseForward(m_clcommand);
    88 	g_Forwards.ReleaseForward(m_clinfochanged);
    89 	g_Forwards.ReleaseForward(m_clauth);
    90 	g_Forwards.ReleaseForward(m_onActivate);
    91 	g_Forwards.ReleaseForward(m_onActivate2);
    92 
    93 	delete [] m_Players;
    94 }
    95 
    96 void PlayerManager::OnServerActivate(edict_t *pEdictList, int edictCount, int clientMax)
    97 {
    98 	if (m_FirstPass)
    99 	{
   100 		/* Initialize all players */
   101 		m_maxClients = clientMax;
   102 		m_PlayerCount = 0;
   103 		m_Players = new CPlayer[m_maxClients + 1];
   104 		m_AuthQueue = new unsigned int[m_maxClients + 1];
   105 		m_FirstPass = false;
   106 
   107 		memset(m_AuthQueue, 0, sizeof(unsigned int) * (m_maxClients + 1));
   108 	}
   109 	m_onActivate->Execute(NULL);
   110 	m_onActivate2->Execute(NULL);
   111 
   112 	static int g_userid_test = 1;
   113 	int client = GetClientOfUserId(++g_userid_test);
   114 }
   115 
   116 void PlayerManager::RunAuthChecks()
   117 {
   118 	CPlayer *pPlayer;
   119 	const char *authstr;
   120 	unsigned int removed = 0;
   121 	for (unsigned int i=1; i<=m_AuthQueue[0]; i++)
   122 	{
   123 		pPlayer = GetPlayerByIndex(m_AuthQueue[i]);
   124 		authstr = engine->GetPlayerNetworkIDString(pPlayer->m_pEdict);
   125 		if (authstr && authstr[0] != '\0'
   126 			&& (strcmp(authstr, "STEAM_ID_PENDING") != 0))
   127 		{
   128 			/* Set authorization */
   129 			pPlayer->m_AuthID.assign(authstr);
   130 			pPlayer->m_IsAuthorized = true;
   131 
   132 			/* Mark as removed from queue */
   133 			unsigned int client = m_AuthQueue[i];
   134 			m_AuthQueue[i] = 0;
   135 			removed++;
   136 
   137 			/* Send to extensions */
   138 			List<IClientListener *>::iterator iter;
   139 			IClientListener *pListener;
   140 			for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   141 			{
   142 				pListener = (*iter);
   143 				pListener->OnClientAuthorized(client, authstr);
   144 				if (!pPlayer->IsConnected())
   145 				{
   146 					break;
   147 				}
   148 			}
   149 
   150 			/* Send to plugins if player is still connected */
   151 			if (pPlayer->IsConnected() && m_clauth->GetFunctionCount())
   152 			{
   153 				/* :TODO: handle the case of a player disconnecting in the middle */
   154 				m_clauth->PushCell(client);
   155 				m_clauth->PushString(authstr);
   156 				m_clauth->Execute(NULL);
   157 			}
   158 		}
   159 	}
   160 
   161 	/* Clean up the queue */
   162 	if (removed)
   163 	{
   164 		/* We don't have to compcat the list if it's empty */
   165 		if (removed != m_AuthQueue[0])
   166 		{
   167 			unsigned int diff = 0;
   168 			for (unsigned int i=1; i<=m_AuthQueue[0]; i++)
   169 			{
   170 				/* If this member is removed... */
   171 				if (m_AuthQueue[i] == 0)
   172 				{
   173 					/* Increase the differential */
   174 					diff++;
   175 				} else {
   176 					/* diff cannot increase faster than i+1 */
   177 					assert(i > diff);
   178 					assert(i - diff >= 1);
   179 					/* move this index down */
   180 					m_AuthQueue[i - diff] = m_AuthQueue[i];
   181 				}
   182 			}
   183 			m_AuthQueue[0] -= removed;
   184 		} else {
   185 			m_AuthQueue[0] = 0;
   186 			g_SourceMod.SetAuthChecking(false);
   187 		}
   188 	}
   189 }
   190 
   191 bool PlayerManager::OnClientConnect(edict_t *pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen)
   192 {
   193 	int client = engine->IndexOfEdict(pEntity);
   194 
   195 	List<IClientListener *>::iterator iter;
   196 	IClientListener *pListener = NULL;
   197 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   198 	{
   199 		pListener = (*iter);
   200 		if (!pListener->InterceptClientConnect(client, reject, maxrejectlen))
   201 		{
   202 			return false;
   203 		}
   204 	}
   205 
   206 	cell_t res = 1;
   207 
   208 	m_Players[client].Initialize(pszName, pszAddress, pEntity);
   209 	m_clconnect->PushCell(client);
   210 	m_clconnect->PushStringEx(reject, maxrejectlen, SM_PARAM_STRING_UTF8, SM_PARAM_COPYBACK);
   211 	m_clconnect->PushCell(maxrejectlen);
   212 	m_clconnect->Execute(&res, NULL);
   213 
   214 	if (res)
   215 	{
   216 		if (!m_Players[client].IsAuthorized())
   217 		{
   218 			m_AuthQueue[++m_AuthQueue[0]] = client;
   219 			g_SourceMod.SetAuthChecking(true);
   220 		}
   221 	} else {
   222 		RETURN_META_VALUE(MRES_SUPERCEDE, false);
   223 	}
   224 
   225 	m_UserIdLookUp[engine->GetPlayerUserId(pEntity)] = client;
   226 
   227 	return true;
   228 }
   229 
   230 bool PlayerManager::OnClientConnect_Post(edict_t *pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen)
   231 {
   232 	int client = engine->IndexOfEdict(pEntity);
   233 	bool orig_value = META_RESULT_ORIG_RET(bool);
   234 	if (orig_value)
   235 	{
   236 		List<IClientListener *>::iterator iter;
   237 		IClientListener *pListener = NULL;
   238 		for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   239 		{
   240 			pListener = (*iter);
   241 			pListener->OnClientConnected(client);
   242 		}
   243 	}
   244 
   245 	return true;
   246 }
   247 
   248 void PlayerManager::OnClientPutInServer(edict_t *pEntity, const char *playername)
   249 {
   250 	cell_t res;
   251 	int client = engine->IndexOfEdict(pEntity);
   252 
   253 	CPlayer *pPlayer = GetPlayerByIndex(client);
   254 	/* If they're not connected, they're a bot */
   255 	if (!pPlayer->IsConnected())
   256 	{
   257 		/* Run manual connection routines */
   258 		char error[255];
   259 		const char *authid = engine->GetPlayerNetworkIDString(pEntity);
   260 		pPlayer->Authorize(authid);
   261 		if (!OnClientConnect(pEntity, playername, "127.0.0.1", error, sizeof(error)))
   262 		{
   263 			/* :TODO: kick the bot if it's rejected */
   264 			return;
   265 		}
   266 		List<IClientListener *>::iterator iter;
   267 		IClientListener *pListener = NULL;
   268 		for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   269 		{
   270 			pListener = (*iter);
   271 			pListener->OnClientConnected(client);
   272 			/* See if bot was kicked */
   273 			if (!pPlayer->IsConnected())
   274 			{
   275 				return;
   276 			}
   277 		}
   278 		/* Now do authorization */
   279 		for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   280 		{
   281 			pListener = (*iter);
   282 			pListener->OnClientAuthorized(client, authid);
   283 			/* See if bot was kicked */
   284 			if (!pPlayer->IsConnected())
   285 			{
   286 				return;
   287 			}
   288 		}
   289 		/* Finally, tell plugins */
   290 		if (m_clauth->GetFunctionCount())
   291 		{
   292 			m_clauth->PushCell(client);
   293 			m_clauth->PushString(authid);
   294 			m_clauth->Execute(NULL);
   295 		}
   296 	}
   297 
   298 	if (playerinfo)
   299 	{
   300 		pPlayer->m_Info = playerinfo->GetPlayerInfo(pEntity);
   301 	}
   302 
   303 	List<IClientListener *>::iterator iter;
   304 	IClientListener *pListener = NULL;
   305 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   306 	{
   307 		pListener = (*iter);
   308 		pListener->OnClientPutInServer(client);
   309 		/* See if player was kicked */
   310 		if (!pPlayer->IsConnected())
   311 		{
   312 			return;
   313 		}
   314 	}
   315 
   316 	m_Players[client].Connect();
   317 	m_PlayerCount++;
   318 	m_clputinserver->PushCell(client);
   319 	m_clputinserver->Execute(&res, NULL);
   320 }
   321 
   322 void PlayerManager::OnClientDisconnect(edict_t *pEntity)
   323 {
   324 	cell_t res;
   325 	int client = engine->IndexOfEdict(pEntity);
   326 
   327 	if (m_Players[client].IsConnected())
   328 	{
   329 		m_cldisconnect->PushCell(client);
   330 		m_cldisconnect->Execute(&res, NULL);
   331 	}
   332 
   333 	if (m_Players[client].IsInGame())
   334 	{
   335 		m_PlayerCount--;
   336 	}
   337 
   338 	List<IClientListener *>::iterator iter;
   339 	IClientListener *pListener = NULL;
   340 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   341 	{
   342 		pListener = (*iter);
   343 		pListener->OnClientDisconnecting(client);
   344 	}
   345 
   346 	/**
   347 	 * Remove client from auth queue if necessary
   348 	 */
   349 	if (!m_Players[client].IsAuthorized())
   350 	{
   351 		for (unsigned int i=1; i<=m_AuthQueue[0]; i++)
   352 		{
   353 			if (m_AuthQueue[i] == (unsigned)client)
   354 			{
   355 				/* Move everything ahead of us back by one */
   356 				for (unsigned int j=i+1; j<=m_AuthQueue[0]; j++)
   357 				{
   358 					m_AuthQueue[j-1] = m_AuthQueue[j];
   359 				}
   360 				/* Remove us and break */
   361 				m_AuthQueue[0]--;
   362 				break;
   363 			}
   364 		}
   365 	}
   366 
   367 	m_Players[client].Disconnect();
   368 	m_UserIdLookUp[engine->GetPlayerUserId(pEntity)] = 0;
   369 }
   370 
   371 void PlayerManager::OnClientDisconnect_Post(edict_t *pEntity)
   372 {
   373 	cell_t res;
   374 	int client = engine->IndexOfEdict(pEntity);
   375 
   376 	m_cldisconnect_post->PushCell(client);
   377 	m_cldisconnect_post->Execute(&res, NULL);
   378 
   379 	List<IClientListener *>::iterator iter;
   380 	IClientListener *pListener = NULL;
   381 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   382 	{
   383 		pListener = (*iter);
   384 		pListener->OnClientDisconnected(client);
   385 	}
   386 }
   387 
   388 void PlayerManager::OnClientCommand(edict_t *pEntity)
   389 {
   390 	cell_t res = Pl_Continue;
   391 	int client = engine->IndexOfEdict(pEntity);
   392 
   393 	int args = engine->Cmd_Argc() - 1;
   394 
   395 	m_clcommand->PushCell(client);
   396 	m_clcommand->PushCell(args);
   397 	m_clcommand->Execute(&res, NULL);
   398 
   399 	if (res >= Pl_Stop)
   400 	{
   401 		RETURN_META(MRES_SUPERCEDE);
   402 	}
   403 
   404 	res = g_ConCmds.DispatchClientCommand(client, (ResultType)res);
   405 
   406 	if (res >= Pl_Handled)
   407 	{
   408 		RETURN_META(MRES_SUPERCEDE);
   409 	}
   410 }
   411 
   412 void PlayerManager::OnClientSettingsChanged(edict_t *pEntity)
   413 {
   414 	cell_t res;
   415 	int client = engine->IndexOfEdict(pEntity);
   416 
   417 	m_clinfochanged->PushCell(engine->IndexOfEdict(pEntity));
   418 	m_clinfochanged->Execute(&res, NULL);
   419 	m_Players[client].SetName(engine->GetClientConVarValue(client, "name"));
   420 }
   421 
   422 int PlayerManager::GetMaxClients()
   423 {
   424 	return m_maxClients;
   425 }
   426 
   427 CPlayer *PlayerManager::GetPlayerByIndex(int client) const
   428 {
   429 	if (client > m_maxClients || client < 1)
   430 	{
   431 		return NULL;
   432 	}
   433 	return &m_Players[client];
   434 }
   435 
   436 int PlayerManager::GetNumPlayers()
   437 {
   438 	return m_PlayerCount;
   439 }
   440 
   441 int PlayerManager::GetClientOfUserId(int userid)
   442 {
   443 	if (userid < 0 || userid > USHRT_MAX)
   444 	{
   445 		return 0;
   446 	}
   447 	
   448 	int client = m_UserIdLookUp[userid];
   449 
   450 	/* Verify the userid.  The cache can get messed up with older
   451 	 * Valve engines.  :TODO: If this gets fixed, do an old engine 
   452 	 * check before invoking this backwards compat code.
   453 	 */
   454 	if (client)
   455 	{
   456 		CPlayer *player = GetPlayerByIndex(client);
   457 		if (player && player->IsConnected())
   458 		{
   459 			int realUserId = engine->GetPlayerUserId(player->GetEdict());
   460 			if (realUserId == userid)
   461 			{
   462 				return client;
   463 			}
   464 		}
   465 	}
   466 
   467 	/* If we can't verify the userid, we have to do a manual loop */
   468 	CPlayer *player;
   469 	for (int i = 1; i <= m_maxClients; i++)
   470 	{
   471 		player = GetPlayerByIndex(i);
   472 		if (!player || !player->IsConnected())
   473 		{
   474 			continue;
   475 		}
   476 		if (engine->GetPlayerUserId(player->GetEdict()) == userid)
   477 		{
   478 			return i;
   479 		}
   480 	}
   481 
   482 	return 0;
   483 }
   484 
   485 void PlayerManager::AddClientListener(IClientListener *listener)
   486 {
   487 	m_hooks.push_back(listener);
   488 }
   489 
   490 void PlayerManager::RemoveClientListener(IClientListener *listener)
   491 {
   492 	m_hooks.remove(listener);
   493 }
   494 
   495 IGamePlayer *PlayerManager::GetGamePlayer(edict_t *pEdict)
   496 {
   497 	int index = engine->IndexOfEdict(pEdict);
   498 	return GetGamePlayer(index);
   499 }
   500 
   501 IGamePlayer *PlayerManager::GetGamePlayer(int client)
   502 {
   503 	return GetPlayerByIndex(client);
   504 }
   505 
   506 void PlayerManager::ClearAdminId(AdminId id)
   507 {
   508 	for (int i=1; i<=m_maxClients; i++)
   509 	{
   510 		if (m_Players[i].m_Admin == id)
   511 		{
   512 			m_Players[i].DumpAdmin(true);
   513 		}
   514 	}
   515 }
   516 
   517 void PlayerManager::ClearAllAdmins()
   518 {
   519 	for (int i=1; i<=m_maxClients; i++)
   520 	{
   521 		m_Players[i].DumpAdmin(true);
   522 	}
   523 }
   524 
   525 
   526 /*******************
   527  *** PLAYER CODE ***
   528  *******************/
   529 
   530 CPlayer::CPlayer()
   531 {
   532 	m_IsConnected = false;
   533 	m_IsInGame = false;
   534 	m_IsAuthorized = false;
   535 	m_pEdict = NULL;
   536 	m_Admin = INVALID_ADMIN_ID;
   537 	m_TempAdmin = false;
   538 	m_Info = NULL;
   539 }
   540 
   541 void CPlayer::Initialize(const char *name, const char *ip, edict_t *pEntity)
   542 {
   543 	m_IsConnected = true;
   544 	m_Name.assign(name);
   545 	m_Ip.assign(ip);
   546 	m_pEdict = pEntity;
   547 }
   548 
   549 void CPlayer::Connect()
   550 {
   551 	m_IsInGame = true;
   552 }
   553 
   554 void CPlayer::Authorize(const char *steamid)
   555 {
   556 	m_IsAuthorized = true;
   557 	m_AuthID.assign(steamid);
   558 }
   559 
   560 void CPlayer::Disconnect()
   561 {
   562 	DumpAdmin(false);
   563 	m_IsConnected = false;
   564 	m_IsInGame = false;
   565 	m_IsAuthorized = false;
   566 	m_Name.clear();
   567 	m_Ip.clear();
   568 	m_AuthID.clear();
   569 	m_pEdict = NULL;
   570 	m_Info = NULL;
   571 }
   572 
   573 void CPlayer::SetName(const char *name)
   574 {
   575 	m_Name.assign(name);
   576 }
   577 
   578 const char *CPlayer::GetName()
   579 {
   580 	return (m_Info) ? m_Info->GetName(): m_Name.c_str();
   581 }
   582 
   583 const char *CPlayer::GetIPAddress()
   584 {
   585 	return m_Ip.c_str();
   586 }
   587 
   588 const char *CPlayer::GetAuthString()
   589 {
   590 	return m_AuthID.c_str();
   591 }
   592 
   593 edict_t *CPlayer::GetEdict()
   594 {
   595 	return m_pEdict;
   596 }
   597 
   598 bool CPlayer::IsInGame()
   599 {
   600 	return m_IsInGame;
   601 }
   602 
   603 bool CPlayer::IsConnected()
   604 {
   605 	return m_IsConnected;
   606 }
   607 
   608 bool CPlayer::IsAuthorized()
   609 {
   610 	return m_IsAuthorized;
   611 }
   612 
   613 IPlayerInfo *CPlayer::GetPlayerInfo()
   614 {
   615 	return m_Info;
   616 }
   617 
   618 bool CPlayer::IsFakeClient()
   619 {
   620 	return (strcmp(m_AuthID.c_str(), "BOT") == 0);
   621 }
   622 
   623 void CPlayer::SetAdminId(AdminId id, bool temporary)
   624 {
   625 	if (!m_IsConnected)
   626 	{
   627 		return;
   628 	}
   629 
   630 	DumpAdmin(false);
   631 
   632 	m_Admin = id;
   633 	m_TempAdmin = temporary;
   634 }
   635 
   636 AdminId CPlayer::GetAdminId()
   637 {
   638 	return m_Admin;
   639 }
   640 
   641 void CPlayer::DumpAdmin(bool deleting)
   642 {
   643 	if (m_Admin != INVALID_ADMIN_ID)
   644 	{
   645 		if (m_TempAdmin && !deleting)
   646 		{
   647 			g_Admins.InvalidateAdmin(m_Admin);
   648 		}
   649 		m_Admin = INVALID_ADMIN_ID;
   650 		m_TempAdmin = false;
   651 	}
   652 }
sourcemod-central
Feed