/**

  * vim: set ts=4 sw=4 tw=99 noet :

  * =============================================================================

  * SourceMod

  * Copyright (C) 2004-2009 AlliedModders LLC.  All rights reserved.

  * =============================================================================

  *

  * This program is free software; you can redistribute it and/or modify it under

  * the terms of the GNU General Public License, version 3.0, as published by the

  * Free Software Foundation.

  * 

  * This program is distributed in the hope that it will be useful, but WITHOUT

  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more

  * details.

  *

  * You should have received a copy of the GNU General Public License along with

  * this program.  If not, see <http://www.gnu.org/licenses/>.

  *

  * As a special exception, AlliedModders LLC gives you permission to link the

  * code of this program (as well as its derivative works) to "Half-Life 2," the

  * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software

  * by the Valve Corporation.  You must obey the GNU General Public License in

  * all respects for all other code used.  Additionally, AlliedModders LLC grants

  * this exception to all derivative works.  AlliedModders LLC defines further

  * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),

  * or <http://www.sourcemod.net/license.php>.

  *

  * Version: $Id$

  */

 #include "PlayerManager.h"

 #include "ForwardSys.h"

 #include "ShareSys.h"

 #include "AdminCache.h"

 #include "ConCmdManager.h"

 #include "MenuStyle_Valve.h"

 #include "MenuStyle_Radio.h"

 #include "sm_stringutil.h"

 #include "CoreConfig.h"

 #include "TimerSys.h"

 #include "Logger.h"

 #include "ChatTriggers.h"

 #include "HalfLife2.h"

 #include <inetchannel.h>

 #include <iclient.h>

 #include <IGameConfigs.h>

 #include "ExtensionSys.h"

 #include <sourcemod_version.h>

 #include "ConsoleDetours.h"

 #include "logic_bridge.h"

 PlayerManager g_Players;

 bool g_OnMapStarted = false;

 IForward *PreAdminCheck = NULL;

 IForward *PostAdminCheck = NULL;

 IForward *PostAdminFilter = NULL;

 const unsigned int *g_NumPlayersToAuth = NULL;

 int lifestate_offset = -1;

 List<ICommandTargetProcessor *> target_processors;

 SH_DECL_HOOK5(IServerGameClients, ClientConnect, SH_NOATTRIB, 0, bool, edict_t *, const char *, const char *, char *, int);

 SH_DECL_HOOK2_void(IServerGameClients, ClientPutInServer, SH_NOATTRIB, 0, edict_t *, const char *);

 SH_DECL_HOOK1_void(IServerGameClients, ClientDisconnect, SH_NOATTRIB, 0, edict_t *);

 #if SOURCE_ENGINE >= SE_ORANGEBOX

 SH_DECL_HOOK2_void(IServerGameClients, ClientCommand, SH_NOATTRIB, 0, edict_t *, const CCommand &);

 #else

 SH_DECL_HOOK1_void(IServerGameClients, ClientCommand, SH_NOATTRIB, 0, edict_t *);

 #endif

 SH_DECL_HOOK1_void(IServerGameClients, ClientSettingsChanged, SH_NOATTRIB, 0, edict_t *);

 SH_DECL_HOOK3_void(IServerGameDLL, ServerActivate, SH_NOATTRIB, 0, edict_t *, int, int);

 #if SOURCE_ENGINE >= SE_ORANGEBOX

 SH_DECL_EXTERN1_void(ConCommand, Dispatch, SH_NOATTRIB, false, const CCommand &);

 #elif SOURCE_ENGINE == SE_DARKMESSIAH

 SH_DECL_EXTERN0_void(ConCommand, Dispatch, SH_NOATTRIB, false);

 #else

 # if SH_IMPL_VERSION >= 4

  extern int __SourceHook_FHAddConCommandDispatch(void *,bool,class fastdelegate::FastDelegate0<void>);

 # else

  extern bool __SourceHook_FHAddConCommandDispatch(void *,bool,class fastdelegate::FastDelegate0<void>);

 # endif

 extern bool __SourceHook_FHRemoveConCommandDispatch(void *,bool,class fastdelegate::FastDelegate0<void>);

 #endif

 ConCommand *maxplayersCmd = NULL;

 unsigned int g_PlayerSerialCount = 0;

 class KickPlayerTimer : public ITimedEvent

 {

 public:

 	ResultType OnTimer(ITimer *pTimer, void *pData)

 	{

 		int userid = (int)pData;

 		int client = g_Players.GetClientOfUserId(userid);

 		if (client)

 		{

 			CPlayer *player = g_Players.GetPlayerByIndex(client);

 			player->Kick("Your name is reserved by SourceMod; set your password to use it.");

 		}

 		return Pl_Stop;

 	}

 	void OnTimerEnd(ITimer *pTimer, void *pData)

 	{

 	}

 } s_KickPlayerTimer;

 PlayerManager::PlayerManager()

 {

 	m_AuthQueue = NULL;

 	m_FirstPass = false;

 	m_maxClients = 0;

 	m_SourceTVUserId = -1;

 	m_ReplayUserId = -1;

 	m_bAuthstringValidation = true; // use steam auth by default

 	m_UserIdLookUp = new int[USHRT_MAX+1];

 	memset(m_UserIdLookUp, 0, sizeof(int) * (USHRT_MAX+1));

 }

 PlayerManager::~PlayerManager()

 {

 	g_NumPlayersToAuth = NULL;

 	delete [] m_AuthQueue;

 	delete [] m_UserIdLookUp;

 }

 void PlayerManager::OnSourceModAllInitialized()

 {

 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect, false);

 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect_Post, true);

 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientPutInServer, serverClients, this, &PlayerManager::OnClientPutInServer, true);

 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect, false);

 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect_Post, true);

 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientCommand, serverClients, this, &PlayerManager::OnClientCommand, false);

 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientSettingsChanged, serverClients, this, &PlayerManager::OnClientSettingsChanged, true);

 	SH_ADD_HOOK_MEMFUNC(IServerGameDLL, ServerActivate, gamedll, this, &PlayerManager::OnServerActivate, true);

 	g_ShareSys.AddInterface(NULL, this);

 	ParamType p1[] = {Param_Cell, Param_String, Param_Cell};

 	ParamType p2[] = {Param_Cell};

 	m_clconnect = g_Forwards.CreateForward("OnClientConnect", ET_LowEvent, 3, p1);

 	m_clconnect_post = g_Forwards.CreateForward("OnClientConnected", ET_Ignore, 1, p2);

 	m_clputinserver = g_Forwards.CreateForward("OnClientPutInServer", ET_Ignore, 1, p2);

 	m_cldisconnect = g_Forwards.CreateForward("OnClientDisconnect", ET_Ignore, 1, p2);

 	m_cldisconnect_post = g_Forwards.CreateForward("OnClientDisconnect_Post", ET_Ignore, 1, p2);

 	m_clcommand = g_Forwards.CreateForward("OnClientCommand", ET_Hook, 2, NULL, Param_Cell, Param_Cell);

 	m_clinfochanged = g_Forwards.CreateForward("OnClientSettingsChanged", ET_Ignore, 1, p2);

 	m_clauth = g_Forwards.CreateForward("OnClientAuthorized", ET_Ignore, 2, NULL, Param_Cell, Param_String);

 	m_onActivate = g_Forwards.CreateForward("OnServerLoad", ET_Ignore, 0, NULL);

 	m_onActivate2 = g_Forwards.CreateForward("OnMapStart", ET_Ignore, 0, NULL);

 	PreAdminCheck = g_Forwards.CreateForward("OnClientPreAdminCheck", ET_Event, 1, p1);

 	PostAdminCheck = g_Forwards.CreateForward("OnClientPostAdminCheck", ET_Ignore, 1, p1);

 	PostAdminFilter = g_Forwards.CreateForward("OnClientPostAdminFilter", ET_Ignore, 1, p1);

 	m_bIsListenServer = !engine->IsDedicatedServer();

 	m_ListenClient = 0;

 	ConCommand *pCmd = FindCommand("maxplayers");

 	if (pCmd != NULL)

 	{

 		SH_ADD_HOOK_STATICFUNC(ConCommand, Dispatch, pCmd, CmdMaxplayersCallback, true);

 		maxplayersCmd = pCmd;

 	}

 }

 void PlayerManager::OnSourceModShutdown()

 {

 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect, false);

 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect_Post, true);

 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientPutInServer, serverClients, this, &PlayerManager::OnClientPutInServer, true);

 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect, false);

 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect_Post, true);

 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientCommand, serverClients, this, &PlayerManager::OnClientCommand, false);

 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientSettingsChanged, serverClients, this, &PlayerManager::OnClientSettingsChanged, true);

 	SH_REMOVE_HOOK_MEMFUNC(IServerGameDLL, ServerActivate, gamedll, this, &PlayerManager::OnServerActivate, true);

 	/* Release forwards */

 	g_Forwards.ReleaseForward(m_clconnect);

 	g_Forwards.ReleaseForward(m_clconnect_post);

 	g_Forwards.ReleaseForward(m_clputinserver);

 	g_Forwards.ReleaseForward(m_cldisconnect);

 	g_Forwards.ReleaseForward(m_cldisconnect_post);

 	g_Forwards.ReleaseForward(m_clcommand);

 	g_Forwards.ReleaseForward(m_clinfochanged);

 	g_Forwards.ReleaseForward(m_clauth);

 	g_Forwards.ReleaseForward(m_onActivate);

 	g_Forwards.ReleaseForward(m_onActivate2);

 	g_Forwards.ReleaseForward(PreAdminCheck);

 	g_Forwards.ReleaseForward(PostAdminCheck);

 	g_Forwards.ReleaseForward(PostAdminFilter);

 	delete [] m_Players;

 	if (maxplayersCmd != NULL)

 	{

 		SH_REMOVE_HOOK_STATICFUNC(ConCommand, Dispatch, maxplayersCmd, CmdMaxplayersCallback, true);

 	}

 }

 ConfigResult PlayerManager::OnSourceModConfigChanged(const char *key, 

 												 const char *value, 

 												 ConfigSource source, 

 												 char *error, 

 												 size_t maxlength)

 {

 	if (strcmp(key, "PassInfoVar") == 0)

 	{

 		if (strcmp(value, "_password") != 0)

 		{

 			m_PassInfoVar.assign(value);

 		}

 		return ConfigResult_Accept;

 	} else if (strcmp(key, "AllowClLanguageVar") == 0) {

 		if (strcasecmp(value, "on") == 0)

 		{

 			m_QueryLang = true;

 		} else if (strcasecmp(value, "off") == 0) {

 			m_QueryLang = false;

 		} else {

 			UTIL_Format(error, maxlength, "Invalid value: must be \"on\" or \"off\"");

 			return ConfigResult_Reject;

 		}

 		return ConfigResult_Accept;

 	} else if (strcmp( key, "SteamAuthstringValidation" ) == 0) {

 		if (strcasecmp(value, "yes") == 0)

 		{

 			m_bAuthstringValidation = true;

 		} else if ( strcasecmp(value, "no") == 0) {

 			m_bAuthstringValidation = false;

 		} else {

 			UTIL_Format(error, maxlength, "Invalid value: must be \"yes\" or \"no\"");

 			return ConfigResult_Reject;

 		}

 		return ConfigResult_Accept;

 	}

 	return ConfigResult_Ignore;

 }

 void PlayerManager::OnServerActivate(edict_t *pEdictList, int edictCount, int clientMax)

 {

 	static ConVar *tv_enable = icvar->FindVar("tv_enable");

 #if SOURCE_ENGINE == SE_ORANGEBOXVALVE

 	static ConVar *replay_enable = icvar->FindVar("replay_enable");

 #endif

 	// clientMax will not necessarily be correct here (such as on late SourceTV enable)

 	m_maxClients = gpGlobals->maxClients;

 	ICommandLine *commandLine = g_HL2.GetValveCommandLine();

 	m_bIsSourceTVActive = (tv_enable && tv_enable->GetBool() && (!commandLine || commandLine->FindParm("-nohltv") == 0));

 	m_bIsReplayActive = false;

 #if SOURCE_ENGINE == SE_ORANGEBOXVALVE

 	m_bIsReplayActive = (replay_enable && replay_enable->GetBool());

 #endif

 	m_PlayersSinceActive = 0;

 	if (!m_FirstPass)

 	{

 		/* Initialize all players */

 		m_PlayerCount = 0;

 		m_Players = new CPlayer[ABSOLUTE_PLAYER_LIMIT + 1];

 		m_AuthQueue = new unsigned int[ABSOLUTE_PLAYER_LIMIT + 1];

 		m_FirstPass = true;

 		memset(m_AuthQueue, 0, sizeof(unsigned int) * (ABSOLUTE_PLAYER_LIMIT + 1));

 		g_NumPlayersToAuth = &m_AuthQueue[0];

 	}

 	g_PluginSys.SyncMaxClients(m_maxClients);

 	g_OnMapStarted = true;

 	g_Extensions.CallOnCoreMapStart(pEdictList, edictCount, m_maxClients);

 	m_onActivate->Execute(NULL);

 	m_onActivate2->Execute(NULL);

 	List<IClientListener *>::iterator iter;

 	for (iter = m_hooks.begin(); iter != m_hooks.end(); iter++)

 	{

 		if ((*iter)->GetClientListenerVersion() >= 5)

 		{

 			(*iter)->OnServerActivated(m_maxClients);

 		}

 	}

 	SMGlobalClass *cls = SMGlobalClass::head;

 	while (cls)

 	{

 		cls->OnSourceModLevelActivated();

 		cls = cls->m_pGlobalClassNext;

 	}

 	SM_ExecuteAllConfigs();

 }

 bool PlayerManager::IsServerActivated()

 {

 	return m_FirstPass;

 }

 bool PlayerManager::CheckSetAdmin(int index, CPlayer *pPlayer, AdminId id)

 {

 	const char *password = g_Admins.GetAdminPassword(id);

 	if (password != NULL)

 	{

 		if (m_PassInfoVar.size() < 1)

 		{

 			return false;

 		}

 		/* Whoa... the user needs a password! */

 		const char *given = engine->GetClientConVarValue(index, m_PassInfoVar.c_str());

 		if (!given || strcmp(given, password) != 0)

 		{

 			return false;

 		}

 	}

 	pPlayer->SetAdminId(id, false);

 	return true;

 }

 bool PlayerManager::CheckSetAdminName(int index, CPlayer *pPlayer, AdminId id)

 {

 	const char *password = g_Admins.GetAdminPassword(id);

 	if (password == NULL)

 	{

 		return false;

 	}

 	if (m_PassInfoVar.size() < 1)

 	{

 		return false;

 	}

 	/* Whoa... the user needs a password! */

 	const char *given = engine->GetClientConVarValue(index, m_PassInfoVar.c_str());

 	if (!given || strcmp(given, password) != 0)

 	{

 		return false;

 	}

 	pPlayer->SetAdminId(id, false);

 	return true;

 }

 void PlayerManager::RunAuthChecks()

 {

 	CPlayer *pPlayer;

 	const char *authstr;

 	unsigned int removed = 0;

 	for (unsigned int i=1; i<=m_AuthQueue[0]; i++)

 	{

 		pPlayer = &m_Players[m_AuthQueue[i]];

 		authstr = engine->GetPlayerNetworkIDString(pPlayer->m_pEdict);

 		pPlayer->SetAuthString(authstr);

 		if (!pPlayer->IsAuthStringValidated())

 		{

 			continue; // we're using steam auth, and steam doesn't know about this player yet so we can't do anything about them for now

 		}

 		if (authstr && authstr[0] != '\0'

 			&& (strcmp(authstr, "STEAM_ID_PENDING") != 0))

 		{

 			/* Set authorization */

 			pPlayer->Authorize();

 			/* Mark as removed from queue */

 			unsigned int client = m_AuthQueue[i];

 			m_AuthQueue[i] = 0;

 			removed++;

 			/* Send to extensions */

 			List<IClientListener *>::iterator iter;

 			IClientListener *pListener;

 			for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

 			{

 				pListener = (*iter);

 				pListener->OnClientAuthorized(client, authstr);

 				if (!pPlayer->IsConnected())

 				{

 					break;

 				}

 			}

 			/* Send to plugins if player is still connected */

 			if (pPlayer->IsConnected() && m_clauth->GetFunctionCount())

 			{

 				/* :TODO: handle the case of a player disconnecting in the middle */

 				m_clauth->PushCell(client);

 				m_clauth->PushString(authstr);

 				m_clauth->Execute(NULL);

 			}

 			if (pPlayer->IsConnected())

 			{

 				pPlayer->Authorize_Post();

 			}

 		}

 	}

 	/* Clean up the queue */

 	if (removed)

 	{

 		/* We don't have to compact the list if it's empty */

 		if (removed != m_AuthQueue[0])

 		{

 			unsigned int diff = 0;

 			for (unsigned int i=1; i<=m_AuthQueue[0]; i++)

 			{

 				/* If this member is removed... */

 				if (m_AuthQueue[i] == 0)

 				{

 					/* Increase the differential */

 					diff++;

 				} else {

 					/* diff cannot increase faster than i+1 */

 					assert(i > diff);

 					assert(i - diff >= 1);

 					/* move this index down */

 					m_AuthQueue[i - diff] = m_AuthQueue[i];

 				}

 			}

 			m_AuthQueue[0] -= removed;

 		} else {

 			m_AuthQueue[0] = 0;

 		}

 	}

 }

 bool PlayerManager::OnClientConnect(edict_t *pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen)

 {

 	int client = IndexOfEdict(pEntity);

 	CPlayer *pPlayer = &m_Players[client];

 	++m_PlayersSinceActive;

 	pPlayer->Initialize(pszName, pszAddress, pEntity);

 	/* Get the client's language */

 	if (m_QueryLang)

 	{

 		const char *name;

 		if (!pPlayer->IsFakeClient() && (name=engine->GetClientConVarValue(client, "cl_language")))

 		{

 			unsigned int langid;

 			pPlayer->m_LangId = (translator->GetLanguageByName(name, &langid)) ? langid : translator->GetServerLanguage();

 		} else {

 			pPlayer->m_LangId = translator->GetServerLanguage();

 		}

 	}

 	List<IClientListener *>::iterator iter;

 	IClientListener *pListener = NULL;

 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

 	{

 		pListener = (*iter);

 		if (!pListener->InterceptClientConnect(client, reject, maxrejectlen))

 		{

 			RETURN_META_VALUE(MRES_SUPERCEDE, false);

 		}

 	}

 	cell_t res = 1;

 	m_clconnect->PushCell(client);

 	m_clconnect->PushStringEx(reject, maxrejectlen, SM_PARAM_STRING_UTF8 | SM_PARAM_STRING_COPY, SM_PARAM_COPYBACK);

 	m_clconnect->PushCell(maxrejectlen);

 	m_clconnect->Execute(&res);

 	if (res)

 	{

 		if (!pPlayer->IsAuthorized())

 		{

 			m_AuthQueue[++m_AuthQueue[0]] = client;

 		}

 		m_UserIdLookUp[engine->GetPlayerUserId(pEntity)] = client;

 	}

 	else

 	{

 		if (!pPlayer->IsFakeClient())

 		{

 			RETURN_META_VALUE(MRES_SUPERCEDE, false);

 		}

 	}

 	return true;

 }

 bool PlayerManager::OnClientConnect_Post(edict_t *pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen)

 {

 	int client = IndexOfEdict(pEntity);

 	bool orig_value = META_RESULT_ORIG_RET(bool);

 	CPlayer *pPlayer = &m_Players[client];

 	if (orig_value)

 	{

 		List<IClientListener *>::iterator iter;

 		IClientListener *pListener = NULL;

 		for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

 		{

 			pListener = (*iter);

 			pListener->OnClientConnected(client);

 			if (!pPlayer->IsConnected())

 			{

 				return true;

 			}

 		}

 		if (!pPlayer->IsFakeClient() 

 			&& m_bIsListenServer

 			&& strncmp(pszAddress, "127.0.0.1", 9) == 0)

 		{

 			m_ListenClient = client;

 		}

 		cell_t res;

 		m_clconnect_post->PushCell(client);

 		m_clconnect_post->Execute(&res, NULL);

 	}

 	else

 	{

 		InvalidatePlayer(pPlayer);

 	}

 	return true;

 }

 void PlayerManager::OnClientPutInServer(edict_t *pEntity, const char *playername)

 {

 	cell_t res;

 	int client = IndexOfEdict(pEntity);

 	CPlayer *pPlayer = &m_Players[client];

 	/* If they're not connected, they're a bot */

 	if (!pPlayer->IsConnected())

 	{

 		/* Run manual connection routines */

 		char error[255];

 		const char *authid = engine->GetPlayerNetworkIDString(pEntity);

 		pPlayer->SetAuthString(authid);

 		pPlayer->Authorize();

 		pPlayer->m_bFakeClient = true;

 		/*

 		 * While we're already filtered to just bots, we'll do other checks to

 		 * make sure that the requisite services are enabled and that the bots

 		 * have joined at the expected time.

 		 *

 		 * Checking playerinfo's IsHLTV and IsReplay would be better and less

 		 * error-prone but will always show false until later in the frame,

 		 * after PutInServer and Activate, and we want it now!

 		 *

 		 * These checks are hairy as hell due to differences between engines and games.

 		 * 

 		 * Most engines use "Replay" and "SourceTV" as bot names for these when they're

 		 * created. EP2V, CSS and Nuclear Dawn (but not L4D2) differ from this by now using

 		 * replay_/tv_name directly when creating the bot(s). To complicate it slightly

 		 * further, the cvar can be empty and the engine's fallback to "unnamed" will be used.

 		 * We can maybe just rip out the name checks at some point and rely solely on whether

 		 * they're enabled and the join order.

 		 */

 		// This doesn't actually get incremented until OnClientConnect. Fake it to check.

 		int newCount = m_PlayersSinceActive + 1;

 		int userId = engine->GetPlayerUserId(pEntity);

 #if (SOURCE_ENGINE == SE_ORANGEBOXVALVE || SOURCE_ENGINE == SE_CSS || SOURCE_ENGINE == SE_LEFT4DEAD2)

 		static ConVar *tv_name = icvar->FindVar("tv_name");

 #endif

 #if SOURCE_ENGINE == SE_ORANGEBOXVALVE

 		static ConVar *replay_name = icvar->FindVar("replay_name");

 #endif

 #if SOURCE_ENGINE == SE_LEFT4DEAD2

 		static bool bIsNuclearDawn = (strcmp(g_SourceMod.GetGameFolderName(), "nucleardawn") == 0);

 #endif

 #if SOURCE_ENGINE == SE_ORANGEBOXVALVE

 		if (m_bIsReplayActive && newCount == 1

 			&& (m_ReplayUserId == userId

 				|| (replay_name && strcmp(playername, replay_name->GetString()) == 0) || (replay_name && replay_name->GetString()[0] == 0 && strcmp(playername, "unnamed") == 0)

 				)

 			)

 		{

 			pPlayer->m_bIsReplay = true;

 			m_ReplayUserId = userId;

 		}

 #endif

 		if (m_bIsSourceTVActive

 			&& ((!m_bIsReplayActive && newCount == 1)

 				|| (m_bIsReplayActive && newCount == 2))

 			&& (m_SourceTVUserId == userId

 #if SOURCE_ENGINE == SE_CSGO

 				|| strcmp(playername, "GOTV") == 0

 #elif (SOURCE_ENGINE == SE_ORANGEBOXVALVE || SOURCE_ENGINE == SE_CSS || SOURCE_ENGINE == SE_LEFT4DEAD2)

 #if SOURCE_ENGINE == SE_LEFT4DEAD2

 				|| (bIsNuclearDawn && ( true

 #endif // SE_LEFT4DEAD2

 				|| (tv_name && strcmp(playername, tv_name->GetString()) == 0) || (tv_name && tv_name->GetString()[0] == 0 && strcmp(playername, "unnamed") == 0)

 #if SOURCE_ENGINE == SE_LEFT4DEAD2

 					))

 				|| (!bIsNuclearDawn && strcmp(playername, "SourceTV") == 0)

 #endif // SE_LEFT4DEAD2

 #else

 				|| strcmp(playername, "SourceTV") == 0

 #endif

 				)

 			)

 		{

 			pPlayer->m_bIsSourceTV = true;

 			m_SourceTVUserId = userId;

 		}

 		if (!OnClientConnect(pEntity, playername, "127.0.0.1", error, sizeof(error)))

 		{

 			/* :TODO: kick the bot if it's rejected */

 			return;

 		}

 		List<IClientListener *>::iterator iter;

 		IClientListener *pListener = NULL;

 		for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

 		{

 			pListener = (*iter);

 			pListener->OnClientConnected(client);

 			/* See if bot was kicked */

 			if (!pPlayer->IsConnected())

 			{

 				return;

 			}

 		}

 		cell_t res;

 		m_clconnect_post->PushCell(client);

 		m_clconnect_post->Execute(&res, NULL);

 		/* Now do authorization */

 		for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

 		{

 			pListener = (*iter);

 			pListener->OnClientAuthorized(client, authid);

 		}

 		/* Finally, tell plugins */

 		if (m_clauth->GetFunctionCount())

 		{

 			m_clauth->PushCell(client);

 			m_clauth->PushString(authid);

 			m_clauth->Execute(NULL);

 		}

 		pPlayer->Authorize_Post();

 	}

 	if (playerinfo)

 	{

 		pPlayer->m_Info = playerinfo->GetPlayerInfo(pEntity);

 	}

 	pPlayer->Connect();

 	m_PlayerCount++;

 	List<IClientListener *>::iterator iter;

 	IClientListener *pListener = NULL;

 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

 	{

 		pListener = (*iter);

 		pListener->OnClientPutInServer(client);

 	}

 	m_clputinserver->PushCell(client);

 	m_clputinserver->Execute(&res, NULL);

 	if (pPlayer->IsAuthorized())

 	{

 		pPlayer->DoPostConnectAuthorization();

 	}

 }

 void PlayerManager::OnSourceModLevelEnd()

 {

 	/* Disconnect all bots still in game */

 	for (int i=1; i<=m_maxClients; i++)

 	{

 		if (m_Players[i].IsConnected())

 		{

 			OnClientDisconnect(m_Players[i].GetEdict());

 		}

 	}

 	m_PlayerCount = 0;

 }

 void PlayerManager::OnClientDisconnect(edict_t *pEntity)

 {

 	cell_t res;

 	int client = IndexOfEdict(pEntity);

 	CPlayer *pPlayer = &m_Players[client];

 	if (pPlayer->IsConnected())

 	{

 		m_cldisconnect->PushCell(client);

 		m_cldisconnect->Execute(&res, NULL);

 	}

 	else

 	{

 		/* We don't care, prevent a double call */

 		return;

 	}

 	if (pPlayer->WasCountedAsInGame())

 	{

 		m_PlayerCount--;

 	}

 	List<IClientListener *>::iterator iter;

 	IClientListener *pListener = NULL;

 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

 	{

 		pListener = (*iter);

 		pListener->OnClientDisconnecting(client);

 	}

 	InvalidatePlayer(pPlayer);

 	if (m_ListenClient == client)

 	{

 		m_ListenClient = 0;

 	}

 }

 void PlayerManager::OnClientDisconnect_Post(edict_t *pEntity)

 {

 	cell_t res;

 	int client = IndexOfEdict(pEntity);

 	m_cldisconnect_post->PushCell(client);

 	m_cldisconnect_post->Execute(&res, NULL);

 	List<IClientListener *>::iterator iter;

 	IClientListener *pListener = NULL;

 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

 	{

 		pListener = (*iter);

 		pListener->OnClientDisconnected(client);

 	}

 }

 void ClientConsolePrint(edict_t *e, const char *fmt, ...)

 {

 	char buffer[512];

 	va_list ap;

 	va_start(ap, fmt);

 	size_t len = vsnprintf(buffer, sizeof(buffer), fmt, ap);

 	va_end(ap);

 	if (len >= sizeof(buffer) - 1)

 	{

 		buffer[sizeof(buffer) - 2] = '\n';

 		buffer[sizeof(buffer) - 1] = '\0';

 	} else {

 		buffer[len++] = '\n';

 		buffer[len] = '\0';

 	}

 	engine->ClientPrintf(e, buffer);

 }

 #if SOURCE_ENGINE >= SE_ORANGEBOX

 void PlayerManager::OnClientCommand(edict_t *pEntity, const CCommand &args)

 {

 #else

 void PlayerManager::OnClientCommand(edict_t *pEntity)

 {

 	CCommand args;

 #endif

 	int client = IndexOfEdict(pEntity);

 	cell_t res = Pl_Continue;

 	CPlayer *pPlayer = &m_Players[client];

 	if (!pPlayer->IsConnected())

 	{

 		return;

 	}

 	if (strcmp(args.Arg(0), "sm") == 0)

 	{

 		if (args.ArgC() > 1 && strcmp(args.Arg(1), "plugins") == 0)

 		{

 			g_PluginSys.ListPluginsToClient(pPlayer, args);

 			RETURN_META(MRES_SUPERCEDE);

 		}

 		else if (args.ArgC() > 1 && strcmp(args.Arg(1), "exts") == 0)

 		{

 			g_Extensions.ListExtensionsToClient(pPlayer, args);

 			RETURN_META(MRES_SUPERCEDE);

 		}

 		else if (args.ArgC() > 1 && strcmp(args.Arg(1), "credits") == 0)

 		{

  			ClientConsolePrint(pEntity,

  				"SourceMod would not be possible without:");

  			ClientConsolePrint(pEntity,

 				" David \"BAILOPAN\" Anderson, Matt \"pRED\" Woodrow");

  			ClientConsolePrint(pEntity,

 				" Scott \"DS\" Ehlert, Fyren");

  			ClientConsolePrint(pEntity,

 				" Nicholas \"psychonic\" Hastings, Asher \"asherkin\" Baker");

 			ClientConsolePrint(pEntity,

 				" Borja \"faluco\" Ferrer, Pavol \"PM OnoTo\" Marko");

 			ClientConsolePrint(pEntity,

 				"SourceMod is open source under the GNU General Public License.");

 			RETURN_META(MRES_SUPERCEDE);

 		}

 		ClientConsolePrint(pEntity,

 			"SourceMod %s, by AlliedModders LLC", SM_VERSION_STRING);

 		ClientConsolePrint(pEntity,

 			"To see running plugins, type \"sm plugins\"");