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