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