Home - sourcemod-central - file revision - core/PlayerManager.cpp@7d8b449edd60 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>
Tue Jul 24 17:05:46 2007 +0000 (2007-07-24)
changeset 1160 7d8b449edd60
parent 978 54782a83a1ef
child 1161 b122ca4464ec
permissions -rw-r--r--
added password support 
     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 #include "MenuStyle_Valve.h"
    21 #include "MenuStyle_Radio.h"
    22 #include "sm_stringutil.h"
    23 #include "CoreConfig.h"
    24 
    25 PlayerManager g_Players;
    26 bool g_OnMapStarted = false;
    27 
    28 SH_DECL_HOOK5(IServerGameClients, ClientConnect, SH_NOATTRIB, 0, bool, edict_t *, const char *, const char *, char *, int);
    29 SH_DECL_HOOK2_void(IServerGameClients, ClientPutInServer, SH_NOATTRIB, 0, edict_t *, const char *);
    30 SH_DECL_HOOK1_void(IServerGameClients, ClientDisconnect, SH_NOATTRIB, 0, edict_t *);
    31 SH_DECL_HOOK1_void(IServerGameClients, ClientCommand, SH_NOATTRIB, 0, edict_t *);
    32 SH_DECL_HOOK1_void(IServerGameClients, ClientSettingsChanged, SH_NOATTRIB, 0, edict_t *);
    33 SH_DECL_HOOK3_void(IServerGameDLL, ServerActivate, SH_NOATTRIB, 0, edict_t *, int, int);
    34 
    35 PlayerManager::PlayerManager()
    36 {
    37 	m_AuthQueue = NULL;
    38 	m_FirstPass = true;
    39 
    40 	m_UserIdLookUp = new int[USHRT_MAX];
    41 	memset(m_UserIdLookUp, 0, sizeof(int) * USHRT_MAX);
    42 }
    43 
    44 PlayerManager::~PlayerManager()
    45 {
    46 	delete [] m_AuthQueue;
    47 	delete [] m_UserIdLookUp;
    48 }
    49 
    50 void PlayerManager::OnSourceModAllInitialized()
    51 {
    52 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect, false);
    53 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect_Post, true);
    54 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientPutInServer, serverClients, this, &PlayerManager::OnClientPutInServer, true);
    55 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect, false);
    56 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect_Post, true);
    57 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientCommand, serverClients, this, &PlayerManager::OnClientCommand, false);
    58 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientSettingsChanged, serverClients, this, &PlayerManager::OnClientSettingsChanged, true);
    59 	SH_ADD_HOOK_MEMFUNC(IServerGameDLL, ServerActivate, gamedll, this, &PlayerManager::OnServerActivate, true);
    60 
    61 	g_ShareSys.AddInterface(NULL, this);
    62 
    63 	ParamType p1[] = {Param_Cell, Param_String, Param_Cell};
    64 	ParamType p2[] = {Param_Cell};
    65 
    66 	m_clconnect = g_Forwards.CreateForward("OnClientConnect", ET_Event, 3, p1);
    67 	m_clputinserver = g_Forwards.CreateForward("OnClientPutInServer", ET_Ignore, 1, p2);
    68 	m_cldisconnect = g_Forwards.CreateForward("OnClientDisconnect", ET_Ignore, 1, p2);
    69 	m_cldisconnect_post = g_Forwards.CreateForward("OnClientDisconnect_Post", ET_Ignore, 1, p2);
    70 	m_clcommand = g_Forwards.CreateForward("OnClientCommand", ET_Hook, 2, NULL, Param_Cell, Param_Cell);
    71 	m_clinfochanged = g_Forwards.CreateForward("OnClientSettingsChanged", ET_Ignore, 1, p2);
    72 	m_clauth = g_Forwards.CreateForward("OnClientAuthorized", ET_Ignore, 2, NULL, Param_Cell, Param_String);
    73 	m_onActivate = g_Forwards.CreateForward("OnServerLoad", ET_Ignore, 0, NULL);
    74 	m_onActivate2 = g_Forwards.CreateForward("OnMapStart", ET_Ignore, 0, NULL);
    75 }
    76 
    77 void PlayerManager::OnSourceModShutdown()
    78 {
    79 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect, false);
    80 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientPutInServer, serverClients, this, &PlayerManager::OnClientPutInServer, true);
    81 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect, false);
    82 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect_Post, true);
    83 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientCommand, serverClients, this, &PlayerManager::OnClientCommand, false);
    84 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientSettingsChanged, serverClients, this, &PlayerManager::OnClientSettingsChanged, true);
    85 	SH_REMOVE_HOOK_MEMFUNC(IServerGameDLL, ServerActivate, gamedll, this, &PlayerManager::OnServerActivate, true);
    86 
    87 	/* Release forwards */
    88 	g_Forwards.ReleaseForward(m_clconnect);
    89 	g_Forwards.ReleaseForward(m_clputinserver);
    90 	g_Forwards.ReleaseForward(m_cldisconnect);
    91 	g_Forwards.ReleaseForward(m_cldisconnect_post);
    92 	g_Forwards.ReleaseForward(m_clcommand);
    93 	g_Forwards.ReleaseForward(m_clinfochanged);
    94 	g_Forwards.ReleaseForward(m_clauth);
    95 	g_Forwards.ReleaseForward(m_onActivate);
    96 	g_Forwards.ReleaseForward(m_onActivate2);
    97 
    98 	delete [] m_Players;
    99 }
   100 
   101 ConfigResult PlayerManager::OnSourceModConfigChanged(const char *key, 
   102 												 const char *value, 
   103 												 ConfigSource source, 
   104 												 char *error, 
   105 												 size_t maxlength)
   106 {
   107 	if (strcmp(key, "PassInfoVar") == 0)
   108 	{
   109 		if (strcmp(value, "_password") != 0)
   110 		{
   111 			m_PassInfoVar.assign(value);
   112 		}
   113 		return ConfigResult_Accept;
   114 	}
   115 	return ConfigResult_Ignore;
   116 }
   117 
   118 void PlayerManager::OnServerActivate(edict_t *pEdictList, int edictCount, int clientMax)
   119 {
   120 	if (m_FirstPass)
   121 	{
   122 		/* Initialize all players */
   123 		m_maxClients = clientMax;
   124 		m_PlayerCount = 0;
   125 		m_Players = new CPlayer[m_maxClients + 1];
   126 		m_AuthQueue = new unsigned int[m_maxClients + 1];
   127 		m_FirstPass = false;
   128 
   129 		memset(m_AuthQueue, 0, sizeof(unsigned int) * (m_maxClients + 1));
   130 	}
   131 	m_onActivate->Execute(NULL);
   132 	m_onActivate2->Execute(NULL);
   133 
   134 	g_OnMapStarted = true;
   135 
   136 	SM_ExecuteAllConfigs();
   137 }
   138 
   139 bool PlayerManager::CheckSetAdmin(int index, CPlayer *pPlayer, AdminId id)
   140 {
   141 	const char *password = g_Admins.GetAdminPassword(id);
   142 	if (password != NULL)
   143 	{
   144 		if (m_PassInfoVar.size() < 1)
   145 		{
   146 			return false;
   147 		}
   148 
   149 		/* Whoa... the user needs a password! */
   150 		const char *given = engine->GetClientConVarValue(index, m_PassInfoVar.c_str());
   151 		if (!given || strcmp(given, password) != 0)
   152 		{
   153 			return false;
   154 		}
   155 	}
   156 
   157 	pPlayer->SetAdminId(id, false);
   158 
   159 	return true;
   160 }
   161 
   162 void PlayerManager::RunAuthChecks()
   163 {
   164 	CPlayer *pPlayer;
   165 	const char *authstr;
   166 	unsigned int removed = 0;
   167 	for (unsigned int i=1; i<=m_AuthQueue[0]; i++)
   168 	{
   169 		pPlayer = GetPlayerByIndex(m_AuthQueue[i]);
   170 		authstr = engine->GetPlayerNetworkIDString(pPlayer->m_pEdict);
   171 		if (authstr && authstr[0] != '\0'
   172 			&& (strcmp(authstr, "STEAM_ID_PENDING") != 0))
   173 		{
   174 			/* Set authorization */
   175 			pPlayer->m_AuthID.assign(authstr);
   176 			pPlayer->m_IsAuthorized = true;
   177 
   178 			/* Mark as removed from queue */
   179 			unsigned int client = m_AuthQueue[i];
   180 			m_AuthQueue[i] = 0;
   181 			removed++;
   182 
   183 			/* Do admin lookups */
   184 			if (pPlayer->GetAdminId() == INVALID_ADMIN_ID)
   185 			{
   186 				AdminId id = g_Admins.FindAdminByIdentity("steam", authstr);
   187 				if (id != INVALID_ADMIN_ID)
   188 				{
   189 					CheckSetAdmin(client, pPlayer, id);
   190 				}
   191 			}
   192 
   193 			/* Send to extensions */
   194 			List<IClientListener *>::iterator iter;
   195 			IClientListener *pListener;
   196 			for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   197 			{
   198 				pListener = (*iter);
   199 				pListener->OnClientAuthorized(client, authstr);
   200 				if (!pPlayer->IsConnected())
   201 				{
   202 					break;
   203 				}
   204 			}
   205 
   206 			/* Send to plugins if player is still connected */
   207 			if (pPlayer->IsConnected() && m_clauth->GetFunctionCount())
   208 			{
   209 				/* :TODO: handle the case of a player disconnecting in the middle */
   210 				m_clauth->PushCell(client);
   211 				m_clauth->PushString(authstr);
   212 				m_clauth->Execute(NULL);
   213 			}
   214 		}
   215 	}
   216 
   217 	/* Clean up the queue */
   218 	if (removed)
   219 	{
   220 		/* We don't have to compact the list if it's empty */
   221 		if (removed != m_AuthQueue[0])
   222 		{
   223 			unsigned int diff = 0;
   224 			for (unsigned int i=1; i<=m_AuthQueue[0]; i++)
   225 			{
   226 				/* If this member is removed... */
   227 				if (m_AuthQueue[i] == 0)
   228 				{
   229 					/* Increase the differential */
   230 					diff++;
   231 				} else {
   232 					/* diff cannot increase faster than i+1 */
   233 					assert(i > diff);
   234 					assert(i - diff >= 1);
   235 					/* move this index down */
   236 					m_AuthQueue[i - diff] = m_AuthQueue[i];
   237 				}
   238 			}
   239 			m_AuthQueue[0] -= removed;
   240 		} else {
   241 			m_AuthQueue[0] = 0;
   242 			g_SourceMod.SetAuthChecking(false);
   243 		}
   244 	}
   245 }
   246 
   247 bool PlayerManager::OnClientConnect(edict_t *pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen)
   248 {
   249 	int client = engine->IndexOfEdict(pEntity);
   250 
   251 	List<IClientListener *>::iterator iter;
   252 	IClientListener *pListener = NULL;
   253 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   254 	{
   255 		pListener = (*iter);
   256 		if (!pListener->InterceptClientConnect(client, reject, maxrejectlen))
   257 		{
   258 			return false;
   259 		}
   260 	}
   261 
   262 	cell_t res = 1;
   263 
   264 	m_Players[client].Initialize(pszName, pszAddress, pEntity);
   265 	m_clconnect->PushCell(client);
   266 	m_clconnect->PushStringEx(reject, maxrejectlen, SM_PARAM_STRING_UTF8, SM_PARAM_COPYBACK);
   267 	m_clconnect->PushCell(maxrejectlen);
   268 	m_clconnect->Execute(&res, NULL);
   269 
   270 	if (res)
   271 	{
   272 		if (!m_Players[client].IsAuthorized())
   273 		{
   274 			m_AuthQueue[++m_AuthQueue[0]] = client;
   275 			g_SourceMod.SetAuthChecking(true);
   276 		}
   277 	} else {
   278 		RETURN_META_VALUE(MRES_SUPERCEDE, false);
   279 	}
   280 
   281 	m_UserIdLookUp[engine->GetPlayerUserId(pEntity)] = client;
   282 
   283 	return true;
   284 }
   285 
   286 bool PlayerManager::OnClientConnect_Post(edict_t *pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen)
   287 {
   288 	int client = engine->IndexOfEdict(pEntity);
   289 	bool orig_value = META_RESULT_ORIG_RET(bool);
   290 	CPlayer *pPlayer = GetPlayerByIndex(client);
   291 	if (orig_value)
   292 	{
   293 		List<IClientListener *>::iterator iter;
   294 		IClientListener *pListener = NULL;
   295 		for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   296 		{
   297 			pListener = (*iter);
   298 			pListener->OnClientConnected(client);
   299 			if (!pPlayer->IsConnected())
   300 			{
   301 				break;
   302 			}
   303 		}
   304 	}
   305 
   306 	if (pPlayer->IsConnected())
   307 	{
   308 		/* Do an ip based lookup */
   309 		char ip[24], *ptr;
   310 		strncopy(ip, pszAddress, sizeof(ip));
   311 		if ((ptr = strchr(ip, ':')) != NULL)
   312 		{
   313 			*ptr = '\0';
   314 		}
   315 		
   316 		AdminId id = g_Admins.FindAdminByIdentity("ip", ip);
   317 		if (id != INVALID_ADMIN_ID)
   318 		{
   319 			CheckSetAdmin(client, pPlayer, id);
   320 		}
   321 	}
   322 
   323 	return true;
   324 }
   325 
   326 void PlayerManager::OnClientPutInServer(edict_t *pEntity, const char *playername)
   327 {
   328 	cell_t res;
   329 	int client = engine->IndexOfEdict(pEntity);
   330 
   331 	CPlayer *pPlayer = GetPlayerByIndex(client);
   332 	/* If they're not connected, they're a bot */
   333 	if (!pPlayer->IsConnected())
   334 	{
   335 		/* Run manual connection routines */
   336 		char error[255];
   337 		const char *authid = engine->GetPlayerNetworkIDString(pEntity);
   338 		pPlayer->Authorize(authid);
   339 		if (!OnClientConnect(pEntity, playername, "127.0.0.1", error, sizeof(error)))
   340 		{
   341 			/* :TODO: kick the bot if it's rejected */
   342 			return;
   343 		}
   344 		List<IClientListener *>::iterator iter;
   345 		IClientListener *pListener = NULL;
   346 		for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   347 		{
   348 			pListener = (*iter);
   349 			pListener->OnClientConnected(client);
   350 			/* See if bot was kicked */
   351 			if (!pPlayer->IsConnected())
   352 			{
   353 				return;
   354 			}
   355 		}
   356 		/* Now do authorization */
   357 		for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   358 		{
   359 			pListener = (*iter);
   360 			pListener->OnClientAuthorized(client, authid);
   361 			/* See if bot was kicked */
   362 			if (!pPlayer->IsConnected())
   363 			{
   364 				return;
   365 			}
   366 		}
   367 		/* Finally, tell plugins */
   368 		if (m_clauth->GetFunctionCount())
   369 		{
   370 			m_clauth->PushCell(client);
   371 			m_clauth->PushString(authid);
   372 			m_clauth->Execute(NULL);
   373 		}
   374 	}
   375 
   376 	if (playerinfo)
   377 	{
   378 		pPlayer->m_Info = playerinfo->GetPlayerInfo(pEntity);
   379 	}
   380 
   381 	List<IClientListener *>::iterator iter;
   382 	IClientListener *pListener = NULL;
   383 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   384 	{
   385 		pListener = (*iter);
   386 		pListener->OnClientPutInServer(client);
   387 		/* See if player was kicked */
   388 		if (!pPlayer->IsConnected())
   389 		{
   390 			return;
   391 		}
   392 	}
   393 
   394 	m_Players[client].Connect();
   395 	m_PlayerCount++;
   396 	m_clputinserver->PushCell(client);
   397 	m_clputinserver->Execute(&res, NULL);
   398 }
   399 
   400 void PlayerManager::OnSourceModLevelEnd()
   401 {
   402 	/* Disconnect all bots still in game */
   403 	for (int i=1; i<=m_maxClients; i++)
   404 	{
   405 		if (m_Players[i].IsConnected() && m_Players[i].IsFakeClient())
   406 		{
   407 			OnClientDisconnect(m_Players[i].GetEdict());
   408 		}
   409 	}
   410 }
   411 
   412 void PlayerManager::OnClientDisconnect(edict_t *pEntity)
   413 {
   414 	cell_t res;
   415 	int client = engine->IndexOfEdict(pEntity);
   416 
   417 	if (m_Players[client].IsConnected())
   418 	{
   419 		m_cldisconnect->PushCell(client);
   420 		m_cldisconnect->Execute(&res, NULL);
   421 	}
   422 
   423 	if (m_Players[client].IsInGame())
   424 	{
   425 		m_PlayerCount--;
   426 	}
   427 
   428 	List<IClientListener *>::iterator iter;
   429 	IClientListener *pListener = NULL;
   430 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   431 	{
   432 		pListener = (*iter);
   433 		pListener->OnClientDisconnecting(client);
   434 	}
   435 
   436 	/**
   437 	 * Remove client from auth queue if necessary
   438 	 */
   439 	if (!m_Players[client].IsAuthorized())
   440 	{
   441 		for (unsigned int i=1; i<=m_AuthQueue[0]; i++)
   442 		{
   443 			if (m_AuthQueue[i] == (unsigned)client)
   444 			{
   445 				/* Move everything ahead of us back by one */
   446 				for (unsigned int j=i+1; j<=m_AuthQueue[0]; j++)
   447 				{
   448 					m_AuthQueue[j-1] = m_AuthQueue[j];
   449 				}
   450 				/* Remove us and break */
   451 				m_AuthQueue[0]--;
   452 				break;
   453 			}
   454 		}
   455 	}
   456 
   457 	m_Players[client].Disconnect();
   458 	m_UserIdLookUp[engine->GetPlayerUserId(pEntity)] = 0;
   459 }
   460 
   461 void PlayerManager::OnClientDisconnect_Post(edict_t *pEntity)
   462 {
   463 	cell_t res;
   464 	int client = engine->IndexOfEdict(pEntity);
   465 
   466 	m_cldisconnect_post->PushCell(client);
   467 	m_cldisconnect_post->Execute(&res, NULL);
   468 
   469 	List<IClientListener *>::iterator iter;
   470 	IClientListener *pListener = NULL;
   471 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   472 	{
   473 		pListener = (*iter);
   474 		pListener->OnClientDisconnected(client);
   475 	}
   476 }
   477 
   478 void PlayerManager::OnClientCommand(edict_t *pEntity)
   479 {
   480 	int client = engine->IndexOfEdict(pEntity);
   481 	cell_t res = Pl_Continue;
   482 
   483 	bool result = g_ValveMenuStyle.OnClientCommand(client);
   484 	if (result)
   485 	{
   486 		res = Pl_Handled;
   487 	} else {
   488 		result = g_RadioMenuStyle.OnClientCommand(client);
   489 		if (result)
   490 		{
   491 			res = Pl_Handled;
   492 		}
   493 	}
   494 
   495 	int args = engine->Cmd_Argc() - 1;
   496 
   497 	cell_t res2 = Pl_Continue;
   498 	m_clcommand->PushCell(client);
   499 	m_clcommand->PushCell(args);
   500 	m_clcommand->Execute(&res2, NULL);
   501 
   502 	if (res2 > res)
   503 	{
   504 		res = res2;
   505 	}
   506 
   507 	if (res >= Pl_Stop)
   508 	{
   509 		RETURN_META(MRES_SUPERCEDE);
   510 	}
   511 
   512 	res = g_ConCmds.DispatchClientCommand(client, (ResultType)res);
   513 
   514 	if (res >= Pl_Handled)
   515 	{
   516 		RETURN_META(MRES_SUPERCEDE);
   517 	}
   518 }
   519 
   520 void PlayerManager::OnClientSettingsChanged(edict_t *pEntity)
   521 {
   522 	cell_t res;
   523 	int client = engine->IndexOfEdict(pEntity);
   524 
   525 	m_clinfochanged->PushCell(engine->IndexOfEdict(pEntity));
   526 	m_clinfochanged->Execute(&res, NULL);
   527 	m_Players[client].SetName(engine->GetClientConVarValue(client, "name"));
   528 }
   529 
   530 int PlayerManager::GetMaxClients()
   531 {
   532 	return m_maxClients;
   533 }
   534 
   535 CPlayer *PlayerManager::GetPlayerByIndex(int client) const
   536 {
   537 	if (client > m_maxClients || client < 1)
   538 	{
   539 		return NULL;
   540 	}
   541 	return &m_Players[client];
   542 }
   543 
   544 int PlayerManager::GetNumPlayers()
   545 {
   546 	return m_PlayerCount;
   547 }
   548 
   549 int PlayerManager::GetClientOfUserId(int userid)
   550 {
   551 	if (userid < 0 || userid > USHRT_MAX)
   552 	{
   553 		return 0;
   554 	}
   555 	
   556 	int client = m_UserIdLookUp[userid];
   557 
   558 	/* Verify the userid.  The cache can get messed up with older
   559 	 * Valve engines.  :TODO: If this gets fixed, do an old engine 
   560 	 * check before invoking this backwards compat code.
   561 	 */
   562 	if (client)
   563 	{
   564 		CPlayer *player = GetPlayerByIndex(client);
   565 		if (player && player->IsConnected())
   566 		{
   567 			int realUserId = engine->GetPlayerUserId(player->GetEdict());
   568 			if (realUserId == userid)
   569 			{
   570 				return client;
   571 			}
   572 		}
   573 	}
   574 
   575 	/* If we can't verify the userid, we have to do a manual loop */
   576 	CPlayer *player;
   577 	for (int i = 1; i <= m_maxClients; i++)
   578 	{
   579 		player = GetPlayerByIndex(i);
   580 		if (!player || !player->IsConnected())
   581 		{
   582 			continue;
   583 		}
   584 		if (engine->GetPlayerUserId(player->GetEdict()) == userid)
   585 		{
   586 			m_UserIdLookUp[userid] = i;
   587 			return i;
   588 		}
   589 	}
   590 
   591 	return 0;
   592 }
   593 
   594 void PlayerManager::AddClientListener(IClientListener *listener)
   595 {
   596 	m_hooks.push_back(listener);
   597 }
   598 
   599 void PlayerManager::RemoveClientListener(IClientListener *listener)
   600 {
   601 	m_hooks.remove(listener);
   602 }
   603 
   604 IGamePlayer *PlayerManager::GetGamePlayer(edict_t *pEdict)
   605 {
   606 	int index = engine->IndexOfEdict(pEdict);
   607 	return GetGamePlayer(index);
   608 }
   609 
   610 IGamePlayer *PlayerManager::GetGamePlayer(int client)
   611 {
   612 	return GetPlayerByIndex(client);
   613 }
   614 
   615 void PlayerManager::ClearAdminId(AdminId id)
   616 {
   617 	for (int i=1; i<=m_maxClients; i++)
   618 	{
   619 		if (m_Players[i].m_Admin == id)
   620 		{
   621 			m_Players[i].DumpAdmin(true);
   622 		}
   623 	}
   624 }
   625 
   626 void PlayerManager::ClearAllAdmins()
   627 {
   628 	for (int i=1; i<=m_maxClients; i++)
   629 	{
   630 		m_Players[i].DumpAdmin(true);
   631 	}
   632 }
   633 
   634 
   635 /*******************
   636  *** PLAYER CODE ***
   637  *******************/
   638 
   639 CPlayer::CPlayer()
   640 {
   641 	m_IsConnected = false;
   642 	m_IsInGame = false;
   643 	m_IsAuthorized = false;
   644 	m_pEdict = NULL;
   645 	m_Admin = INVALID_ADMIN_ID;
   646 	m_TempAdmin = false;
   647 	m_Info = NULL;
   648 }
   649 
   650 void CPlayer::Initialize(const char *name, const char *ip, edict_t *pEntity)
   651 {
   652 	m_IsConnected = true;
   653 	m_Name.assign(name);
   654 	m_Ip.assign(ip);
   655 	m_pEdict = pEntity;
   656 }
   657 
   658 void CPlayer::Connect()
   659 {
   660 	m_IsInGame = true;
   661 }
   662 
   663 void CPlayer::Authorize(const char *steamid)
   664 {
   665 	m_IsAuthorized = true;
   666 	m_AuthID.assign(steamid);
   667 }
   668 
   669 void CPlayer::Disconnect()
   670 {
   671 	DumpAdmin(false);
   672 	m_IsConnected = false;
   673 	m_IsInGame = false;
   674 	m_IsAuthorized = false;
   675 	m_Name.clear();
   676 	m_Ip.clear();
   677 	m_AuthID.clear();
   678 	m_pEdict = NULL;
   679 	m_Info = NULL;
   680 }
   681 
   682 void CPlayer::SetName(const char *name)
   683 {
   684 	m_Name.assign(name);
   685 }
   686 
   687 const char *CPlayer::GetName()
   688 {
   689 	return (m_Info) ? m_Info->GetName(): m_Name.c_str();
   690 }
   691 
   692 const char *CPlayer::GetIPAddress()
   693 {
   694 	return m_Ip.c_str();
   695 }
   696 
   697 const char *CPlayer::GetAuthString()
   698 {
   699 	return m_AuthID.c_str();
   700 }
   701 
   702 edict_t *CPlayer::GetEdict()
   703 {
   704 	return m_pEdict;
   705 }
   706 
   707 bool CPlayer::IsInGame()
   708 {
   709 	return m_IsInGame;
   710 }
   711 
   712 bool CPlayer::IsConnected()
   713 {
   714 	return m_IsConnected;
   715 }
   716 
   717 bool CPlayer::IsAuthorized()
   718 {
   719 	return m_IsAuthorized;
   720 }
   721 
   722 IPlayerInfo *CPlayer::GetPlayerInfo()
   723 {
   724 	return m_Info;
   725 }
   726 
   727 bool CPlayer::IsFakeClient()
   728 {
   729 	return (strcmp(m_AuthID.c_str(), "BOT") == 0);
   730 }
   731 
   732 void CPlayer::SetAdminId(AdminId id, bool temporary)
   733 {
   734 	if (!m_IsConnected)
   735 	{
   736 		return;
   737 	}
   738 
   739 	DumpAdmin(false);
   740 
   741 	m_Admin = id;
   742 	m_TempAdmin = temporary;
   743 }
   744 
   745 AdminId CPlayer::GetAdminId()
   746 {
   747 	return m_Admin;
   748 }
   749 
   750 void CPlayer::DumpAdmin(bool deleting)
   751 {
   752 	if (m_Admin != INVALID_ADMIN_ID)
   753 	{
   754 		if (m_TempAdmin && !deleting)
   755 		{
   756 			g_Admins.InvalidateAdmin(m_Admin);
   757 		}
   758 		m_Admin = INVALID_ADMIN_ID;
   759 		m_TempAdmin = false;
   760 	}
   761 }
sourcemod-central
Feed