Home - sourcemod-central - file revision - core/PlayerManager.cpp@ef60870067ff Mercurial
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
core/PlayerManager.cpp
author Scott Ehlert <ds@alliedmods.net>
Thu Mar 22 21:50:20 2007 +0000 (2007-03-22)
changeset 653 ef60870067ff
parent 649 4466c5943d4f
child 658 b46ff98c249b
permissions -rw-r--r--
More consistency of some sort...

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