Home - sourcemod-central - file revision - core/smn_player.cpp@d50b36dc6821 Mercurial
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
core/smn_player.cpp
author Nicholas Hastings <skamonkey@gmail.com>
Mon Jul 29 10:03:18 2013 -0400 (2013-07-29)
changeset 3960 d50b36dc6821
parent 3949 3fefd8346c23
child 4217 4c87212c5817
permissions -rw-r--r--
Updated for latest hl2sdk-dota changes. 
     1 /**
     2  * vim: set ts=4 :
     3  * =============================================================================
     4  * SourceMod
     5  * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
     6  * =============================================================================
     7  *
     8  * This program is free software; you can redistribute it and/or modify it under
     9  * the terms of the GNU General Public License, version 3.0, as published by the
    10  * Free Software Foundation.
    11  * 
    12  * This program is distributed in the hope that it will be useful, but WITHOUT
    13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    14  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
    15  * details.
    16  *
    17  * You should have received a copy of the GNU General Public License along with
    18  * this program.  If not, see <http://www.gnu.org/licenses/>.
    19  *
    20  * As a special exception, AlliedModders LLC gives you permission to link the
    21  * code of this program (as well as its derivative works) to "Half-Life 2," the
    22  * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
    23  * by the Valve Corporation.  You must obey the GNU General Public License in
    24  * all respects for all other code used.  Additionally, AlliedModders LLC grants
    25  * this exception to all derivative works.  AlliedModders LLC defines further
    26  * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
    27  * or <http://www.sourcemod.net/license.php>.
    28  *
    29  * Version: $Id$
    30  */
    31 
    32 #include "PlayerManager.h"
    33 #include "AdminCache.h"
    34 #include "sm_stringutil.h"
    35 #include "HalfLife2.h"
    36 #include "sourcemod.h"
    37 #include "ChatTriggers.h"
    38 #include <inetchannel.h>
    39 #include <iclient.h>
    40 
    41 ConVar sm_show_activity("sm_show_activity", "13", FCVAR_SPONLY, "Activity display setting (see sourcemod.cfg)");
    42 
    43 static cell_t sm_GetClientCount(IPluginContext *pCtx, const cell_t *params)
    44 {
    45 	if (params[1])
    46 	{
    47 		return g_Players.NumPlayers();
    48 	}
    49 
    50 	int maxplayers = g_Players.MaxClients();
    51 	int count = 0;
    52 	for (int i=1; i<=maxplayers; ++i)
    53 	{
    54 		CPlayer *pPlayer = g_Players.GetPlayerByIndex(i);
    55 		if ((pPlayer->IsConnected()) && !(pPlayer->IsInGame()))
    56 		{
    57 			count++;
    58 		}
    59 	}
    60 
    61 	return (g_Players.NumPlayers() + count);
    62 }
    63 
    64 static cell_t sm_GetMaxClients(IPluginContext *pCtx, const cell_t *params)
    65 {
    66 	return g_Players.MaxClients();
    67 }
    68 
    69 static cell_t sm_GetMaxHumanPlayers(IPluginContext *pCtx, const cell_t *params)
    70 {
    71 	int maxHumans = -1;
    72 
    73 #if SOURCE_ENGINE >= SE_LEFT4DEAD
    74 	maxHumans = serverClients->GetMaxHumanPlayers();
    75 #endif
    76 
    77 	if( maxHumans == -1 )
    78 	{
    79 		return g_Players.MaxClients();
    80 	}
    81 	
    82 	return maxHumans;
    83 }
    84 
    85 static cell_t sm_GetClientName(IPluginContext *pCtx, const cell_t *params)
    86 {
    87 	int index = params[1];
    88 
    89 	if (index == 0)
    90 	{
    91 		static ConVar *hostname = NULL;
    92 		if (!hostname)
    93 		{
    94 			hostname = icvar->FindVar("hostname");
    95 			if (!hostname)
    96 			{
    97 				return pCtx->ThrowNativeError("Could not find \"hostname\" cvar");
    98 			}
    99 		}
   100 		pCtx->StringToLocalUTF8(params[2], static_cast<size_t>(params[3]), hostname->GetString(), NULL);
   101 		return 1;
   102 	}
   103 
   104 	if ((index < 1) || (index > g_Players.GetMaxClients()))
   105 	{
   106 		return pCtx->ThrowNativeError("Client index %d is invalid", index);
   107 	}
   108 
   109 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(index);
   110 	if (!pPlayer->IsConnected())
   111 	{
   112 		return pCtx->ThrowNativeError("Client %d is not connected", index);
   113 	}
   114 
   115 	pCtx->StringToLocalUTF8(params[2], static_cast<size_t>(params[3]), pPlayer->GetName(), NULL);
   116 	return 1;
   117 }
   118 
   119 static cell_t sm_GetClientIP(IPluginContext *pCtx, const cell_t *params)
   120 {
   121 	int index = params[1];
   122 	if ((index < 1) || (index > g_Players.GetMaxClients()))
   123 	{
   124 		return pCtx->ThrowNativeError("Client index %d is invalid", index);
   125 	}
   126 
   127 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(index);
   128 	if (!pPlayer->IsConnected())
   129 	{
   130 		return pCtx->ThrowNativeError("Client %d is not connected", index);
   131 	}
   132 
   133 	char buf[64], *ptr;
   134 	strcpy(buf, pPlayer->GetIPAddress());
   135 
   136 	if (params[4] && (ptr = strchr(buf, ':')))
   137 	{
   138 		*ptr = '\0';
   139 	}
   140 
   141 	pCtx->StringToLocal(params[2], static_cast<size_t>(params[3]), buf);
   142 	return 1;
   143 }
   144 
   145 static cell_t sm_GetClientAuthStr(IPluginContext *pCtx, const cell_t *params)
   146 {
   147 	int index = params[1];
   148 	if ((index < 1) || (index > g_Players.GetMaxClients()))
   149 	{
   150 		return pCtx->ThrowNativeError("Client index %d is invalid", index);
   151 	}
   152 
   153 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(index);
   154 	if (!pPlayer->IsConnected())
   155 	{
   156 		return pCtx->ThrowNativeError("Client %d is not connected", index);
   157 	}
   158 
   159 	bool validate = true;
   160 	if (params[0] > 3)
   161 	{
   162 		validate = !!params[4];
   163 	}
   164 
   165 	const char *authstr = pPlayer->GetAuthString(validate);
   166 
   167 	if (!authstr || authstr[0] == '\0')
   168 	{
   169 		return 0;
   170 	}
   171 
   172 	pCtx->StringToLocal(params[2], static_cast<size_t>(params[3]), authstr);
   173 
   174 	return 1;
   175 }
   176 
   177 static cell_t sm_GetSteamAccountID(IPluginContext *pCtx, const cell_t *params)
   178 {
   179 	int index = params[1];
   180 	if ((index < 1) || (index > g_Players.GetMaxClients()))
   181 	{
   182 		return pCtx->ThrowNativeError("Client index %d is invalid", index);
   183 	}
   184 
   185 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(index);
   186 	if (!pPlayer->IsConnected())
   187 	{
   188 		return pCtx->ThrowNativeError("Client %d is not connected", index);
   189 	}
   190 
   191 	return pPlayer->GetSteamAccountID(!!params[2]);
   192 }
   193 
   194 static cell_t sm_IsClientConnected(IPluginContext *pCtx, const cell_t *params)
   195 {
   196 	int index = params[1];
   197 	if ((index < 1) || (index > g_Players.GetMaxClients()))
   198 	{
   199 		return pCtx->ThrowNativeError("Client index %d is invalid", index);
   200 	}
   201 
   202 	return (g_Players.GetPlayerByIndex(index)->IsConnected()) ? 1 : 0;
   203 }
   204 
   205 static cell_t sm_IsClientInGame(IPluginContext *pCtx, const cell_t *params)
   206 {
   207 	int index = params[1];
   208 	if ((index < 1) || (index > g_Players.GetMaxClients()))
   209 	{
   210 		return pCtx->ThrowNativeError("Client index %d is invalid", index);
   211 	}
   212 
   213 	return (g_Players.GetPlayerByIndex(index)->IsInGame()) ? 1 : 0;
   214 }
   215 
   216 static cell_t sm_IsClientAuthorized(IPluginContext *pCtx, const cell_t *params)
   217 {
   218 	int index = params[1];
   219 	if ((index < 1) || (index > g_Players.GetMaxClients()))
   220 	{
   221 		return pCtx->ThrowNativeError("Client index %d is invalid", index);
   222 	}
   223 
   224 	return (g_Players.GetPlayerByIndex(index)->IsAuthorized()) ? 1 : 0;
   225 }
   226 
   227 static cell_t sm_IsClientFakeClient(IPluginContext *pCtx, const cell_t *params)
   228 {
   229 	int index = params[1];
   230 	if ((index < 1) || (index > g_Players.GetMaxClients()))
   231 	{
   232 		return pCtx->ThrowNativeError("Client index %d is invalid", index);
   233 	}
   234 
   235 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(index);
   236 	if (!pPlayer->IsConnected())
   237 	{
   238 		return pCtx->ThrowNativeError("Client %d is not connected", index);
   239 	}
   240 
   241 	return (pPlayer->IsFakeClient()) ? 1 : 0;
   242 }
   243 
   244 static cell_t sm_IsClientSourceTV(IPluginContext *pCtx, const cell_t *params)
   245 {
   246 	int index = params[1];
   247 	if ((index < 1) || (index > g_Players.GetMaxClients()))
   248 	{
   249 		return pCtx->ThrowNativeError("Client index %d is invalid", index);
   250 	}
   251 
   252 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(index);
   253 	if (!pPlayer->IsConnected())
   254 	{
   255 		return pCtx->ThrowNativeError("Client %d is not connected", index);
   256 	}
   257 
   258 	return (pPlayer->IsSourceTV()) ? 1 : 0;
   259 }
   260 
   261 static cell_t sm_IsClientReplay(IPluginContext *pCtx, const cell_t *params)
   262 {
   263 	int index = params[1];
   264 	if ((index < 1) || (index > g_Players.GetMaxClients()))
   265 	{
   266 		return pCtx->ThrowNativeError("Client index %d is invalid", index);
   267 	}
   268 
   269 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(index);
   270 	if (!pPlayer->IsConnected())
   271 	{
   272 		return pCtx->ThrowNativeError("Client %d is not connected", index);
   273 	}
   274 
   275 	return (pPlayer->IsReplay()) ? 1 : 0;
   276 }
   277 
   278 static cell_t IsClientObserver(IPluginContext *pContext, const cell_t *params)
   279 {
   280 	int client = params[1];
   281 
   282 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   283 	if (!pPlayer)
   284 	{
   285 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   286 	} else if (!pPlayer->IsInGame()) {
   287 		return pContext->ThrowNativeError("Client %d is not in game", client);
   288 	}
   289 
   290 	IPlayerInfo *pInfo = pPlayer->GetPlayerInfo();
   291 	if (!pInfo)
   292 	{
   293 		return pContext->ThrowNativeError("IPlayerInfo not supported by game");
   294 	}
   295 
   296 	return pInfo->IsObserver() ? 1 : 0;
   297 }
   298 
   299 static cell_t sm_GetClientInfo(IPluginContext *pContext, const cell_t *params)
   300 {
   301 	int client = params[1];
   302 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   303 	if (!pPlayer)
   304 	{
   305 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   306 	}
   307 	if (!pPlayer->IsConnected())
   308 	{
   309 		return pContext->ThrowNativeError("Client %d is not connected", client);
   310 	}
   311 
   312 	char *key;
   313 	pContext->LocalToString(params[2], &key);
   314 
   315 	const char *val = engine->GetClientConVarValue(client, key);
   316 	if (!val)
   317 	{
   318 		return false;
   319 	}
   320 
   321 	pContext->StringToLocalUTF8(params[3], params[4], val, NULL);
   322 	return 1;
   323 }
   324 
   325 static cell_t SetUserAdmin(IPluginContext *pContext, const cell_t *params)
   326 {
   327 	int client = params[1];
   328 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   329 	if (!pPlayer)
   330 	{
   331 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   332 	}
   333 	if (!pPlayer->IsConnected())
   334 	{
   335 		return pContext->ThrowNativeError("Client %d is not connected", client);
   336 	}
   337 	if (!g_Admins.IsValidAdmin(params[2]) && params[2] != INVALID_ADMIN_ID)
   338 	{
   339 		return pContext->ThrowNativeError("AdminId %x is invalid", params[2]);
   340 	}
   341 
   342 	pPlayer->SetAdminId(params[2], params[3] ? true : false);
   343 
   344 	return 1;
   345 }
   346 
   347 static cell_t GetUserAdmin(IPluginContext *pContext, const cell_t *params)
   348 {
   349 	int client = params[1];
   350 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   351 	if (!pPlayer)
   352 	{
   353 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   354 	}
   355 	if (!pPlayer->IsConnected())
   356 	{
   357 		return pContext->ThrowNativeError("Client %d is not connected", client);
   358 	}
   359 
   360 	return pPlayer->GetAdminId();
   361 }
   362 
   363 static cell_t AddUserFlags(IPluginContext *pContext, const cell_t *params)
   364 {
   365 	int client = params[1];
   366 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   367 	if (!pPlayer)
   368 	{
   369 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   370 	}
   371 	if (!pPlayer->IsConnected())
   372 	{
   373 		return pContext->ThrowNativeError("Client %d is not connected", client);
   374 	}
   375 
   376 	AdminId id;
   377 	if ((id=pPlayer->GetAdminId()) == INVALID_ADMIN_ID)
   378 	{
   379 		id = g_Admins.CreateAdmin(NULL);
   380 		pPlayer->SetAdminId(id, true);
   381 	}
   382 
   383 	cell_t *addr;
   384 	for (int i=2; i<=params[0]; i++)
   385 	{
   386 		pContext->LocalToPhysAddr(params[i], &addr);
   387 		g_Admins.SetAdminFlag(id, (AdminFlag)*addr, true);
   388 	}
   389 
   390 	return 1;
   391 }
   392 
   393 static cell_t RemoveUserFlags(IPluginContext *pContext, const cell_t *params)
   394 {
   395 	int client = params[1];
   396 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   397 	if (!pPlayer)
   398 	{
   399 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   400 	}
   401 	if (!pPlayer->IsConnected())
   402 	{
   403 		return pContext->ThrowNativeError("Client %d is not connected", client);
   404 	}
   405 	
   406 	AdminId id;
   407 	if ((id=pPlayer->GetAdminId()) == INVALID_ADMIN_ID)
   408 	{
   409 		return 0;
   410 	}
   411 
   412 	cell_t *addr;
   413 	for (int i=2; i<=params[0]; i++)
   414 	{
   415 		pContext->LocalToPhysAddr(params[i], &addr);
   416 		g_Admins.SetAdminFlag(id, (AdminFlag)*addr, false);
   417 	}
   418 
   419 	return 1;
   420 }
   421 
   422 static cell_t SetUserFlagBits(IPluginContext *pContext, const cell_t *params)
   423 {
   424 	int client = params[1];
   425 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   426 	if (!pPlayer)
   427 	{
   428 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   429 	}
   430 	if (!pPlayer->IsConnected())
   431 	{
   432 		return pContext->ThrowNativeError("Client %d is not connected", client);
   433 	}
   434 
   435 	AdminId id;
   436 	if ((id=pPlayer->GetAdminId()) == INVALID_ADMIN_ID)
   437 	{
   438 		id = g_Admins.CreateAdmin(NULL);
   439 		pPlayer->SetAdminId(id, true);
   440 	}
   441 
   442 	g_Admins.SetAdminFlags(id, Access_Effective, params[2]);
   443 
   444 	return 1;
   445 }
   446 
   447 static cell_t GetUserFlagBits(IPluginContext *pContext, const cell_t *params)
   448 {
   449 	int client = params[1];
   450 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   451 	if (!pPlayer)
   452 	{
   453 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   454 	}
   455 	if (!pPlayer->IsConnected())
   456 	{
   457 		return pContext->ThrowNativeError("Client %d is not connected", client);
   458 	}
   459 
   460 	AdminId id;
   461 	if ((id=pPlayer->GetAdminId()) == INVALID_ADMIN_ID)
   462 	{
   463 		return 0;
   464 	}
   465 
   466 	return g_Admins.GetAdminFlags(id, Access_Effective);
   467 }
   468 
   469 static cell_t GetClientUserId(IPluginContext *pContext, const cell_t *params)
   470 {
   471 	int client = params[1];
   472 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   473 	if (!pPlayer)
   474 	{
   475 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   476 	}
   477 	if (!pPlayer->IsConnected())
   478 	{
   479 		return pContext->ThrowNativeError("Client %d is not connected", client);
   480 	}
   481 
   482 	return GetPlayerUserId(pPlayer->GetEdict());
   483 }
   484 
   485 static cell_t CanUserTarget(IPluginContext *pContext, const cell_t *params)
   486 {
   487 	int client = params[1];
   488 	int target = params[2];
   489 
   490 	if (client == 0)
   491 	{
   492 		return 1;
   493 	}
   494 
   495 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   496 	if (!pPlayer)
   497 	{
   498 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   499 	} else if (!pPlayer->IsConnected()) {
   500 		return pContext->ThrowNativeError("Client %d is not connected", client);
   501 	}
   502 
   503 	CPlayer *pTarget = g_Players.GetPlayerByIndex(target);
   504 	if (!pTarget)
   505 	{
   506 		return pContext->ThrowNativeError("Client index %d is invalid", target);
   507 	} else if (!pTarget->IsConnected()) {
   508 		return pContext->ThrowNativeError("Client %d is not connected", target);
   509 	}
   510 
   511 	return g_Admins.CanAdminTarget(pPlayer->GetAdminId(), pTarget->GetAdminId()) ? 1 : 0;
   512 }
   513 
   514 static cell_t GetClientTeam(IPluginContext *pContext, const cell_t *params)
   515 {
   516 	int client = params[1];
   517 
   518 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   519 	if (!pPlayer)
   520 	{
   521 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   522 	} else if (!pPlayer->IsInGame()) {
   523 		return pContext->ThrowNativeError("Client %d is not in game", client);
   524 	}
   525 
   526 	IPlayerInfo *pInfo = pPlayer->GetPlayerInfo();
   527 	if (!pInfo)
   528 	{
   529 		return pContext->ThrowNativeError("IPlayerInfo not supported by game");
   530 	}
   531 
   532 	return pInfo->GetTeamIndex();
   533 }
   534 
   535 static cell_t GetFragCount(IPluginContext *pContext, const cell_t *params)
   536 {
   537 	int client = params[1];
   538 
   539 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   540 	if (!pPlayer)
   541 	{
   542 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   543 	} else if (!pPlayer->IsInGame()) {
   544 		return pContext->ThrowNativeError("Client %d is not in game", client);
   545 	}
   546 
   547 	IPlayerInfo *pInfo = pPlayer->GetPlayerInfo();
   548 	if (!pInfo)
   549 	{
   550 		return pContext->ThrowNativeError("IPlayerInfo not supported by game");
   551 	}
   552 
   553 	return pInfo->GetFragCount();
   554 }
   555 
   556 static cell_t GetDeathCount(IPluginContext *pContext, const cell_t *params)
   557 {
   558 	int client = params[1];
   559 
   560 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   561 	if (!pPlayer)
   562 	{
   563 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   564 	} else if (!pPlayer->IsInGame()) {
   565 		return pContext->ThrowNativeError("Client %d is not in game", client);
   566 	}
   567 
   568 	IPlayerInfo *pInfo = pPlayer->GetPlayerInfo();
   569 	if (!pInfo)
   570 	{
   571 		return pContext->ThrowNativeError("IPlayerInfo not supported by game");
   572 	}
   573 
   574 	return pInfo->GetDeathCount();
   575 }
   576 
   577 static cell_t GetArmorValue(IPluginContext *pContext, const cell_t *params)
   578 {
   579 	int client = params[1];
   580 
   581 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   582 	if (!pPlayer)
   583 	{
   584 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   585 	} else if (!pPlayer->IsInGame()) {
   586 		return pContext->ThrowNativeError("Client %d is not in game", client);
   587 	}
   588 
   589 	IPlayerInfo *pInfo = pPlayer->GetPlayerInfo();
   590 	if (!pInfo)
   591 	{
   592 		return pContext->ThrowNativeError("IPlayerInfo not supported by game");
   593 	}
   594 
   595 	return pInfo->GetArmorValue();
   596 }
   597 
   598 static cell_t GetAbsOrigin(IPluginContext *pContext, const cell_t *params)
   599 {
   600 	int client = params[1];
   601 
   602 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   603 	if (!pPlayer)
   604 	{
   605 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   606 	} else if (!pPlayer->IsInGame()) {
   607 		return pContext->ThrowNativeError("Client %d is not in game", client);
   608 	}
   609 
   610 	IPlayerInfo *pInfo = pPlayer->GetPlayerInfo();
   611 	if (!pInfo)
   612 	{
   613 		return pContext->ThrowNativeError("IPlayerInfo not supported by game");
   614 	}
   615 
   616 	cell_t *pVec;
   617 	pContext->LocalToPhysAddr(params[2], &pVec);
   618 
   619 	Vector vec = pInfo->GetAbsOrigin();
   620 	pVec[0] = sp_ftoc(vec.x);
   621 	pVec[1] = sp_ftoc(vec.y);
   622 	pVec[2] = sp_ftoc(vec.z);
   623 
   624 	return 1;
   625 }
   626 
   627 static cell_t GetAbsAngles(IPluginContext *pContext, const cell_t *params)
   628 {
   629 	int client = params[1];
   630 
   631 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   632 	if (!pPlayer)
   633 	{
   634 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   635 	} else if (!pPlayer->IsInGame()) {
   636 		return pContext->ThrowNativeError("Client %d is not in game", client);
   637 	}
   638 
   639 	IPlayerInfo *pInfo = pPlayer->GetPlayerInfo();
   640 	if (!pInfo)
   641 	{
   642 		return pContext->ThrowNativeError("IPlayerInfo not supported by game");
   643 	}
   644 
   645 	cell_t *pAng;
   646 	pContext->LocalToPhysAddr(params[2], &pAng);
   647 
   648 	QAngle ang = pInfo->GetAbsAngles();
   649 	pAng[0] = sp_ftoc(ang.x);
   650 	pAng[1] = sp_ftoc(ang.y);
   651 	pAng[2] = sp_ftoc(ang.z);
   652 
   653 	return 1;
   654 }
   655 
   656 static cell_t GetPlayerMins(IPluginContext *pContext, const cell_t *params)
   657 {
   658 	int client = params[1];
   659 
   660 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   661 	if (!pPlayer)
   662 	{
   663 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   664 	} else if (!pPlayer->IsInGame()) {
   665 		return pContext->ThrowNativeError("Client %d is not in game", client);
   666 	}
   667 
   668 	IPlayerInfo *pInfo = pPlayer->GetPlayerInfo();
   669 	if (!pInfo)
   670 	{
   671 		return pContext->ThrowNativeError("IPlayerInfo not supported by game");
   672 	}
   673 
   674 	cell_t *pVec;
   675 	pContext->LocalToPhysAddr(params[2], &pVec);
   676 
   677 	Vector vec = pInfo->GetPlayerMins();
   678 	pVec[0] = sp_ftoc(vec.x);
   679 	pVec[1] = sp_ftoc(vec.y);
   680 	pVec[2] = sp_ftoc(vec.z);
   681 
   682 	return 1;
   683 }
   684 
   685 static cell_t GetPlayerMaxs(IPluginContext *pContext, const cell_t *params)
   686 {
   687 	int client = params[1];
   688 
   689 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   690 	if (!pPlayer)
   691 	{
   692 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   693 	} else if (!pPlayer->IsInGame()) {
   694 		return pContext->ThrowNativeError("Client %d is not in game", client);
   695 	}
   696 
   697 	IPlayerInfo *pInfo = pPlayer->GetPlayerInfo();
   698 	if (!pInfo)
   699 	{
   700 		return pContext->ThrowNativeError("IPlayerInfo not supported by game");
   701 	}
   702 
   703 	cell_t *pVec;
   704 	pContext->LocalToPhysAddr(params[2], &pVec);
   705 
   706 	Vector vec = pInfo->GetPlayerMaxs();
   707 	pVec[0] = sp_ftoc(vec.x);
   708 	pVec[1] = sp_ftoc(vec.y);
   709 	pVec[2] = sp_ftoc(vec.z);
   710 
   711 	return 1;
   712 }
   713 
   714 static cell_t GetWeaponName(IPluginContext *pContext, const cell_t *params)
   715 {
   716 	int client = params[1];
   717 
   718 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   719 	if (!pPlayer)
   720 	{
   721 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   722 	} else if (!pPlayer->IsInGame()) {
   723 		return pContext->ThrowNativeError("Client %d is not in game", client);
   724 	}
   725 
   726 	IPlayerInfo *pInfo = pPlayer->GetPlayerInfo();
   727 	if (!pInfo)
   728 	{
   729 		return pContext->ThrowNativeError("IPlayerInfo not supported by game");
   730 	}
   731 
   732 	const char *weapon = pInfo->GetWeaponName();
   733 	pContext->StringToLocalUTF8(params[2], static_cast<size_t>(params[3]), weapon ? weapon : "", NULL);
   734 
   735 	return 1;
   736 }
   737 
   738 static cell_t GetModelName(IPluginContext *pContext, const cell_t *params)
   739 {
   740 	int client = params[1];
   741 
   742 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   743 	if (!pPlayer)
   744 	{
   745 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   746 	} else if (!pPlayer->IsInGame()) {
   747 		return pContext->ThrowNativeError("Client %d is not in game", client);
   748 	}
   749 
   750 	IPlayerInfo *pInfo = pPlayer->GetPlayerInfo();
   751 	if (!pInfo)
   752 	{
   753 		return pContext->ThrowNativeError("IPlayerInfo not supported by game");
   754 	}
   755 
   756 	const char *model = pInfo->GetModelName();
   757 	pContext->StringToLocalUTF8(params[2], static_cast<size_t>(params[3]), model ? model : "", NULL);
   758 
   759 	return 1;
   760 }
   761 
   762 static cell_t GetHealth(IPluginContext *pContext, const cell_t *params)
   763 {
   764 	int client = params[1];
   765 
   766 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   767 	if (!pPlayer)
   768 	{
   769 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   770 	} else if (!pPlayer->IsInGame()) {
   771 		return pContext->ThrowNativeError("Client %d is not in game", client);
   772 	}
   773 
   774 	IPlayerInfo *pInfo = pPlayer->GetPlayerInfo();
   775 	if (!pInfo)
   776 	{
   777 		return pContext->ThrowNativeError("IPlayerInfo not supported by game");
   778 	}
   779 
   780 	return pInfo->GetHealth();
   781 }
   782 
   783 static cell_t GetTimeConnected(IPluginContext *pContext, const cell_t *params)
   784 {
   785 	int client = params[1];
   786 
   787 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   788 	if (!pPlayer)
   789 	{
   790 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   791 	} else if (!pPlayer->IsInGame()) {
   792 		return pContext->ThrowNativeError("Client %d is not in game", client);
   793 	} else if (pPlayer->IsFakeClient()) {
   794 		return pContext->ThrowNativeError("Client %d is a bot", client);
   795 	}
   796 
   797 	INetChannelInfo *pInfo = engine->GetPlayerNetInfo(client);
   798 	if (pInfo == NULL)
   799 	{
   800 		return 0;
   801 	}
   802 
   803 	return sp_ftoc(pInfo->GetTimeConnected());
   804 }
   805 
   806 static cell_t GetDataRate(IPluginContext *pContext, const cell_t *params)
   807 {
   808 	int client = params[1];
   809 
   810 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   811 	if (!pPlayer)
   812 	{
   813 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   814 	} else if (!pPlayer->IsInGame()) {
   815 		return pContext->ThrowNativeError("Client %d is not in game", client);
   816 	} else if (pPlayer->IsFakeClient()) {
   817 		return pContext->ThrowNativeError("Client %d is a bot", client);
   818 	}
   819 
   820 	INetChannelInfo *pInfo = engine->GetPlayerNetInfo(client);
   821 	if (pInfo == NULL)
   822 	{
   823 		return 0;
   824 	}
   825 
   826 	return pInfo->GetDataRate();
   827 }
   828 
   829 static cell_t IsTimingOut(IPluginContext *pContext, const cell_t *params)
   830 {
   831 	int client = params[1];
   832 
   833 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   834 	if (!pPlayer)
   835 	{
   836 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   837 	} else if (!pPlayer->IsInGame()) {
   838 		return pContext->ThrowNativeError("Client %d is not in game", client);
   839 	} else if (pPlayer->IsFakeClient()) {
   840 		return pContext->ThrowNativeError("Client %d is a bot", client);
   841 	}
   842 
   843 	INetChannelInfo *pInfo = engine->GetPlayerNetInfo(client);
   844 	if (pInfo == NULL)
   845 	{
   846 		return 1;
   847 	}
   848 
   849 	return pInfo->IsTimingOut() ? 1 : 0;
   850 }
   851 
   852 static cell_t GetLatency(IPluginContext *pContext, const cell_t *params)
   853 {
   854 	int client = params[1];
   855 	float value;
   856 
   857 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   858 	if (!pPlayer)
   859 	{
   860 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   861 	}
   862 	else if (!pPlayer->IsInGame())
   863 	{
   864 		return pContext->ThrowNativeError("Client %d is not in game", client);
   865 	}
   866 	else if (pPlayer->IsFakeClient())
   867 	{
   868 		return pContext->ThrowNativeError("Client %d is a bot", client);
   869 	}
   870 
   871 	INetChannelInfo *pInfo = engine->GetPlayerNetInfo(client);
   872 	if (pInfo == NULL)
   873 	{
   874 		return sp_ftoc(-1);
   875 	}
   876 
   877 	if (params[2] == MAX_FLOWS)
   878 	{
   879 		value = pInfo->GetLatency(FLOW_INCOMING) + pInfo->GetLatency(FLOW_OUTGOING);
   880 	}
   881 	else
   882 	{
   883 		value = pInfo->GetLatency(params[2]);
   884 	}
   885 
   886 	return sp_ftoc(value);
   887 }
   888 
   889 static cell_t GetAvgLatency(IPluginContext *pContext, const cell_t *params)
   890 {
   891 	int client = params[1];
   892 	float value;
   893 
   894 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   895 	if (!pPlayer)
   896 	{
   897 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   898 	}
   899 	else if (!pPlayer->IsInGame())
   900 	{
   901 		return pContext->ThrowNativeError("Client %d is not in game", client);
   902 	}
   903 	else if (pPlayer->IsFakeClient())
   904 	{
   905 		return pContext->ThrowNativeError("Client %d is a bot", client);
   906 	}
   907 
   908 	INetChannelInfo *pInfo = engine->GetPlayerNetInfo(client);
   909 	if (pInfo == NULL)
   910 	{
   911 		return sp_ftoc(-1);
   912 	}
   913 
   914 	if (params[2] == MAX_FLOWS)
   915 	{
   916 		value = pInfo->GetAvgLatency(FLOW_INCOMING) + pInfo->GetAvgLatency(FLOW_OUTGOING);
   917 	}
   918 	else
   919 	{
   920 		value = pInfo->GetAvgLatency(params[2]);
   921 	}
   922 
   923 	return sp_ftoc(value);
   924 }
   925 
   926 static cell_t GetAvgLoss(IPluginContext *pContext, const cell_t *params)
   927 {
   928 	int client = params[1];
   929 	float value;
   930 
   931 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   932 	if (!pPlayer)
   933 	{
   934 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   935 	}
   936 	else if (!pPlayer->IsInGame())
   937 	{
   938 		return pContext->ThrowNativeError("Client %d is not in game", client);
   939 	}
   940 	else if (pPlayer->IsFakeClient())
   941 	{
   942 		return pContext->ThrowNativeError("Client %d is a bot", client);
   943 	}
   944 
   945 	INetChannelInfo *pInfo = engine->GetPlayerNetInfo(client);
   946 	if (pInfo == NULL)
   947 	{
   948 		return sp_ftoc(-1);
   949 	}
   950 
   951 	if (params[2] == MAX_FLOWS)
   952 	{
   953 		value = pInfo->GetAvgLoss(FLOW_INCOMING) + pInfo->GetAvgLoss(FLOW_OUTGOING);
   954 	}
   955 	else
   956 	{
   957 		value = pInfo->GetAvgLoss(params[2]);
   958 	}
   959 
   960 	return sp_ftoc(value);
   961 }
   962 
   963 static cell_t GetAvgChoke(IPluginContext *pContext, const cell_t *params)
   964 {
   965 	int client = params[1];
   966 	float value;
   967 
   968 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
   969 	if (!pPlayer)
   970 	{
   971 		return pContext->ThrowNativeError("Client index %d is invalid", client);
   972 	}
   973 	else if (!pPlayer->IsInGame())
   974 	{
   975 		return pContext->ThrowNativeError("Client %d is not in game", client);
   976 	}
   977 	else if (pPlayer->IsFakeClient())
   978 	{
   979 		return pContext->ThrowNativeError("Client %d is a bot", client);
   980 	}
   981 
   982 	INetChannelInfo *pInfo = engine->GetPlayerNetInfo(client);
   983 	if (pInfo == NULL)
   984 	{
   985 		return sp_ftoc(-1);
   986 	}
   987 
   988 	if (params[2] == MAX_FLOWS)
   989 	{
   990 		value = pInfo->GetAvgChoke(FLOW_INCOMING) + pInfo->GetAvgChoke(FLOW_OUTGOING);
   991 	}
   992 	else
   993 	{
   994 		value = pInfo->GetAvgChoke(params[2]);
   995 	}
   996 
   997 	return sp_ftoc(value);
   998 }
   999 
  1000 static cell_t GetAvgData(IPluginContext *pContext, const cell_t *params)
  1001 {
  1002 	int client = params[1];
  1003 	float value;
  1004 
  1005 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
  1006 	if (!pPlayer)
  1007 	{
  1008 		return pContext->ThrowNativeError("Client index %d is invalid", client);
  1009 	}
  1010 	else if (!pPlayer->IsInGame())
  1011 	{
  1012 		return pContext->ThrowNativeError("Client %d is not in game", client);
  1013 	}
  1014 	else if (pPlayer->IsFakeClient())
  1015 	{
  1016 		return pContext->ThrowNativeError("Client %d is a bot", client);
  1017 	}
  1018 
  1019 	INetChannelInfo *pInfo = engine->GetPlayerNetInfo(client);
  1020 	if (pInfo == NULL)
  1021 	{
  1022 		return 0;
  1023 	}
  1024 
  1025 	if (params[2] == MAX_FLOWS)
  1026 	{
  1027 		value = pInfo->GetAvgData(FLOW_INCOMING) + pInfo->GetAvgData(FLOW_OUTGOING);
  1028 	}
  1029 	else
  1030 	{
  1031 		value = pInfo->GetAvgData(params[2]);
  1032 	}
  1033 
  1034 	return sp_ftoc(value);
  1035 }
  1036 
  1037 static cell_t GetAvgPackets(IPluginContext *pContext, const cell_t *params)
  1038 {
  1039 	int client = params[1];
  1040 	float value;
  1041 
  1042 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
  1043 	if (!pPlayer)
  1044 	{
  1045 		return pContext->ThrowNativeError("Client index %d is invalid", client);
  1046 	}
  1047 	else if (!pPlayer->IsInGame())
  1048 	{
  1049 		return pContext->ThrowNativeError("Client %d is not in game", client);
  1050 	}
  1051 	else if (pPlayer->IsFakeClient())
  1052 	{
  1053 		return pContext->ThrowNativeError("Client %d is a bot", client);
  1054 	}
  1055 
  1056 	INetChannelInfo *pInfo = engine->GetPlayerNetInfo(client);
  1057 
  1058 	if (pInfo == NULL)
  1059 	{
  1060 		return 0;
  1061 	}
  1062 
  1063 	if (params[2] == MAX_FLOWS)
  1064 	{
  1065 		value = pInfo->GetAvgPackets(FLOW_INCOMING) + pInfo->GetAvgPackets(FLOW_OUTGOING);
  1066 	}
  1067 	else
  1068 	{
  1069 		value = pInfo->GetAvgPackets(params[2]);
  1070 	}
  1071 
  1072 	return sp_ftoc(value);
  1073 }
  1074 
  1075 static cell_t GetClientOfUserId(IPluginContext *pContext, const cell_t *params)
  1076 {
  1077 	return g_Players.GetClientOfUserId(params[1]);
  1078 }
  1079 
  1080 static cell_t _ShowActivity(IPluginContext *pContext,
  1081 							const cell_t *params,
  1082 							const char *tag,
  1083 							cell_t fmt_param)
  1084 {
  1085 	char message[255];
  1086 	char buffer[255];
  1087 	int value = sm_show_activity.GetInt();
  1088 	unsigned int replyto = g_ChatTriggers.GetReplyTo();
  1089 	int client = params[1];
  1090 
  1091 	const char *name = "Console";
  1092 	const char *sign = "ADMIN";
  1093 	bool display_in_chat = false;
  1094 	if (client != 0)
  1095 	{
  1096 		CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
  1097 		if (!pPlayer || !pPlayer->IsConnected())
  1098 		{
  1099 			return pContext->ThrowNativeError("Client index %d is invalid", client);
  1100 		}
  1101 		name = pPlayer->GetName();
  1102 		AdminId id = pPlayer->GetAdminId();
  1103 		if (id == INVALID_ADMIN_ID
  1104 			|| !g_Admins.GetAdminFlag(id, Admin_Generic, Access_Effective))
  1105 		{
  1106 			sign = "PLAYER";
  1107 		}
  1108 
  1109 		/* Display the message to the client? */
  1110 		if (replyto == SM_REPLY_CONSOLE)
  1111 		{
  1112 			g_SourceMod.SetGlobalTarget(client);
  1113 			g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, fmt_param);
  1114 
  1115 			if (pContext->GetLastNativeError() != SP_ERROR_NONE)
  1116 			{
  1117 				return 0;
  1118 			}
  1119 
  1120 			UTIL_Format(message, sizeof(message), "%s%s\n", tag, buffer);
  1121 #if SOURCE_ENGINE == SE_DOTA
  1122 			engine->ClientPrintf(pPlayer->GetIndex(), message);
  1123 #else
  1124 			engine->ClientPrintf(pPlayer->GetEdict(), message);
  1125 #endif
  1126 			display_in_chat = true;
  1127 		}
  1128 	}
  1129 	else
  1130 	{
  1131 		g_SourceMod.SetGlobalTarget(SOURCEMOD_SERVER_LANGUAGE);
  1132 		g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, fmt_param);
  1133 
  1134 		if (pContext->GetLastNativeError() != SP_ERROR_NONE)
  1135 		{
  1136 			return 0;
  1137 		}
  1138 
  1139 		UTIL_Format(message, sizeof(message), "%s%s\n", tag, buffer);
  1140 		META_CONPRINT(message);
  1141 	}
  1142 
  1143 	if (!value)
  1144 	{
  1145 		return 1;
  1146 	}
  1147 
  1148 	int maxClients = g_Players.GetMaxClients();
  1149 	for (int i=1; i<=maxClients; i++)
  1150 	{
  1151 		CPlayer *pPlayer = g_Players.GetPlayerByIndex(i);
  1152 		if (!pPlayer->IsInGame() 
  1153 			|| pPlayer->IsFakeClient()
  1154 			|| (display_in_chat && i == client))
  1155 		{
  1156 			continue;
  1157 		}
  1158 		AdminId id = pPlayer->GetAdminId();
  1159 		g_SourceMod.SetGlobalTarget(i);
  1160 		if (id == INVALID_ADMIN_ID
  1161 			|| !g_Admins.GetAdminFlag(id, Admin_Generic, Access_Effective))
  1162 		{
  1163 			/* Treat this as a normal user */
  1164 			if ((value & 1) || (value & 2))
  1165 			{
  1166 				const char *newsign = sign;
  1167 				if ((value & 2) || (i == client))
  1168 				{
  1169 					newsign = name;
  1170 				}
  1171 				g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, fmt_param);
  1172 
  1173 				if (pContext->GetLastNativeError() != SP_ERROR_NONE)
  1174 				{
  1175 					return 0;
  1176 				}
  1177 
  1178 				UTIL_Format(message, sizeof(message), "%s%s: %s", tag, newsign, buffer);
  1179 				g_HL2.TextMsg(i, HUD_PRINTTALK, message);
  1180 			}
  1181 		}
  1182 		else
  1183 		{
  1184 			/* Treat this as an admin user */
  1185 			bool is_root = g_Admins.GetAdminFlag(id, Admin_Root, Access_Effective);
  1186 			if ((value & 4) 
  1187 				|| (value & 8)
  1188 				|| ((value & 16) && is_root))
  1189 			{
  1190 				const char *newsign = sign;
  1191 				if ((value & 8) || ((value & 16) && is_root) || (i == client))
  1192 				{
  1193 					newsign = name;
  1194 				}
  1195 				g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, fmt_param);
  1196 
  1197 				if (pContext->GetLastNativeError() != SP_ERROR_NONE)
  1198 				{
  1199 					return 0;
  1200 				}
  1201 
  1202 				UTIL_Format(message, sizeof(message), "%s%s: %s", tag, newsign, buffer);
  1203 				g_HL2.TextMsg(i, HUD_PRINTTALK, message);
  1204 			}
  1205 		}
  1206 	}
  1207 
  1208 	return 1;
  1209 }
  1210 
  1211 static cell_t _ShowActivity2(IPluginContext *pContext,
  1212 							 const cell_t *params,
  1213 							 const char *tag,
  1214 							 cell_t fmt_param)
  1215 {
  1216 	char message[255];
  1217 	char buffer[255];
  1218 	int value = sm_show_activity.GetInt();
  1219 	unsigned int replyto = g_ChatTriggers.GetReplyTo();
  1220 	int client = params[1];
  1221 
  1222 	const char *name = "Console";
  1223 	const char *sign = "ADMIN";
  1224 	if (client != 0)
  1225 	{
  1226 		CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
  1227 		if (!pPlayer || !pPlayer->IsConnected())
  1228 		{
  1229 			return pContext->ThrowNativeError("Client index %d is invalid", client);
  1230 		}
  1231 		name = pPlayer->GetName();
  1232 		AdminId id = pPlayer->GetAdminId();
  1233 		if (id == INVALID_ADMIN_ID
  1234 			|| !g_Admins.GetAdminFlag(id, Admin_Generic, Access_Effective))
  1235 		{
  1236 			sign = "PLAYER";
  1237 		}
  1238 
  1239 		g_SourceMod.SetGlobalTarget(client);
  1240 		g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, fmt_param);
  1241 
  1242 		if (pContext->GetLastNativeError() != SP_ERROR_NONE)
  1243 		{
  1244 			return 0;
  1245 		}
  1246 
  1247 		/* We don't display directly to the console because the chat text 
  1248 		 * simply gets added to the console, so we don't want it to print 
  1249 		 * twice.
  1250 		 */
  1251 		if (replyto == SM_REPLY_CONSOLE)
  1252 		{
  1253 #if 0
  1254 			UTIL_Format(message, sizeof(message), "%s%s\n", tag, buffer);
  1255 			engine->ClientPrintf(pPlayer->GetEdict(), message);
  1256 #endif
  1257 			UTIL_Format(message, sizeof(message), "%s%s", tag, buffer);
  1258 			g_HL2.TextMsg(client, HUD_PRINTTALK, message);
  1259 		}
  1260 		else
  1261 		{
  1262 			UTIL_Format(message, sizeof(message), "%s%s", tag, buffer);
  1263 			g_HL2.TextMsg(client, HUD_PRINTTALK, message);
  1264 		}
  1265 	}
  1266 	else
  1267 	{
  1268 		g_SourceMod.SetGlobalTarget(SOURCEMOD_SERVER_LANGUAGE);
  1269 		g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, fmt_param);
  1270 
  1271 		if (pContext->GetLastNativeError() != SP_ERROR_NONE)
  1272 		{
  1273 			return 0;
  1274 		}
  1275 
  1276 		UTIL_Format(message, sizeof(message), "%s%s\n", tag, buffer);
  1277 		META_CONPRINT(message);
  1278 	}
  1279 
  1280 	if (!value)
  1281 	{
  1282 		return 1;
  1283 	}
  1284 
  1285 	int maxClients = g_Players.GetMaxClients();
  1286 	for (int i=1; i<=maxClients; i++)
  1287 	{
  1288 		CPlayer *pPlayer = g_Players.GetPlayerByIndex(i);
  1289 		if (!pPlayer->IsInGame() 
  1290 			|| pPlayer->IsFakeClient()
  1291 			|| i == client)
  1292 		{
  1293 			continue;
  1294 		}
  1295 		AdminId id = pPlayer->GetAdminId();
  1296 		g_SourceMod.SetGlobalTarget(i);
  1297 		if (id == INVALID_ADMIN_ID
  1298 			|| !g_Admins.GetAdminFlag(id, Admin_Generic, Access_Effective))
  1299 		{
  1300 			/* Treat this as a normal user */
  1301 			if ((value & 1) || (value & 2))
  1302 			{
  1303 				const char *newsign = sign;
  1304 				if ((value & 2))
  1305 				{
  1306 					newsign = name;
  1307 				}
  1308 				g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, fmt_param);
  1309 
  1310 				if (pContext->GetLastNativeError() != SP_ERROR_NONE)
  1311 				{
  1312 					return 0;
  1313 				}
  1314 
  1315 				UTIL_Format(message, sizeof(message), "%s%s: %s", tag, newsign, buffer);
  1316 				g_HL2.TextMsg(i, HUD_PRINTTALK, message);
  1317 			}
  1318 		}
  1319 		else
  1320 		{
  1321 			/* Treat this as an admin user */
  1322 			bool is_root = g_Admins.GetAdminFlag(id, Admin_Root, Access_Effective);
  1323 			if ((value & 4) 
  1324 				|| (value & 8)
  1325 				|| ((value & 16) && is_root))
  1326 			{
  1327 				const char *newsign = sign;
  1328 				if ((value & 8) || ((value & 16) && is_root))
  1329 				{
  1330 					newsign = name;
  1331 				}
  1332 				g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, fmt_param);
  1333 
  1334 				if (pContext->GetLastNativeError() != SP_ERROR_NONE)
  1335 				{
  1336 					return 0;
  1337 				}
  1338 
  1339 				UTIL_Format(message, sizeof(message), "%s%s: %s", tag, newsign, buffer);
  1340 				g_HL2.TextMsg(i, HUD_PRINTTALK, message);
  1341 			}
  1342 		}
  1343 	}
  1344 
  1345 	return 1;
  1346 }
  1347 
  1348 static cell_t ShowActivity(IPluginContext *pContext, const cell_t *params)
  1349 {
  1350 	return _ShowActivity(pContext, params, "[SM] ", 2);
  1351 }
  1352 
  1353 static cell_t ShowActivityEx(IPluginContext *pContext, const cell_t *params)
  1354 {
  1355 	char *str;
  1356 	pContext->LocalToString(params[2], &str);
  1357 
  1358 	return _ShowActivity(pContext, params, str, 3);
  1359 }
  1360 
  1361 static cell_t ShowActivity2(IPluginContext *pContext, const cell_t *params)
  1362 {
  1363 	char *str;
  1364 	pContext->LocalToString(params[2], &str);
  1365 
  1366 	return _ShowActivity2(pContext, params, str, 3);
  1367 }
  1368 
  1369 static cell_t KickClient(IPluginContext *pContext, const cell_t *params)
  1370 {
  1371 	int client = params[1];
  1372 
  1373 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
  1374 	if (!pPlayer)
  1375 	{
  1376 		return pContext->ThrowNativeError("Client index %d is invalid", client);
  1377 	}
  1378 	else if (!pPlayer->IsConnected())
  1379 	{
  1380 		return pContext->ThrowNativeError("Client %d is not connected", client);
  1381 	}
  1382 
  1383 	/* Ignore duplicate kicks */
  1384 	if (pPlayer->IsInKickQueue())
  1385 	{
  1386 		return 1;
  1387 	}
  1388 
  1389 	g_SourceMod.SetGlobalTarget(client);
  1390 
  1391 	char buffer[256];
  1392 	g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, 2);
  1393 
  1394 	if (pContext->GetLastNativeError() != SP_ERROR_NONE)
  1395 	{
  1396 		return 0;
  1397 	}
  1398 
  1399 	if (pPlayer->IsFakeClient())
  1400 	{
  1401 		// Kick uses the kickid command for bots. It is already delayed
  1402 		// until the next frame unless someone flushes command buffer
  1403 		pPlayer->Kick(buffer);
  1404 		return 1;
  1405 	}
  1406 
  1407 	g_HL2.AddDelayedKick(client, pPlayer->GetUserId(), buffer);
  1408 
  1409 	return 1;
  1410 }
  1411 
  1412 static cell_t KickClientEx(IPluginContext *pContext, const cell_t *params)
  1413 {
  1414 	int client = params[1];
  1415 
  1416 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
  1417 	if (!pPlayer)
  1418 	{
  1419 		return pContext->ThrowNativeError("Client index %d is invalid", client);
  1420 	}
  1421 	else if (!pPlayer->IsConnected())
  1422 	{
  1423 		return pContext->ThrowNativeError("Client %d is not connected", client);
  1424 	}
  1425 
  1426 	g_SourceMod.SetGlobalTarget(client);
  1427 
  1428 	char buffer[256];
  1429 	g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, 2);
  1430 
  1431 	if (pContext->GetLastNativeError() != SP_ERROR_NONE)
  1432 	{
  1433 		return 0;
  1434 	}
  1435 
  1436 	pPlayer->Kick(buffer);
  1437 
  1438 	return 1;
  1439 }
  1440 
  1441 static cell_t ChangeClientTeam(IPluginContext *pContext, const cell_t *params)
  1442 {
  1443 	int client = params[1];
  1444 
  1445 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
  1446 	if (!pPlayer)
  1447 	{
  1448 		return pContext->ThrowNativeError("Client index %d is invalid", client);
  1449 	}
  1450 	else if (!pPlayer->IsInGame())
  1451 	{
  1452 		return pContext->ThrowNativeError("Client %d is not in game", client);
  1453 	}
  1454 
  1455 	IPlayerInfo *pInfo = pPlayer->GetPlayerInfo();
  1456 	if (!pInfo)
  1457 	{
  1458 		return pContext->ThrowNativeError("IPlayerInfo not supported by game");
  1459 	}
  1460 
  1461 	pInfo->ChangeTeam(params[2]);
  1462 
  1463 	return 1;
  1464 }
  1465 
  1466 static cell_t RunAdminCacheChecks(IPluginContext *pContext, const cell_t *params)
  1467 {
  1468 	int client = params[1];
  1469 
  1470 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
  1471 	if (!pPlayer)
  1472 	{
  1473 		return pContext->ThrowNativeError("Client index %d is invalid", client);
  1474 	}
  1475 	else if (!pPlayer->IsInGame())
  1476 	{
  1477 		return pContext->ThrowNativeError("Client %d is not in game", client);
  1478 	}
  1479 	else if (!pPlayer->IsAuthorized())
  1480 	{
  1481 		return pContext->ThrowNativeError("Client %d is not authorized", client);
  1482 	}
  1483 
  1484 	AdminId id = pPlayer->GetAdminId();
  1485 	pPlayer->DoBasicAdminChecks();
  1486 
  1487 	return (id != pPlayer->GetAdminId()) ? 1 : 0;
  1488 }
  1489 
  1490 static cell_t NotifyPostAdminCheck(IPluginContext *pContext, const cell_t *params)
  1491 {
  1492 	int client = params[1];
  1493 
  1494 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
  1495 	if (!pPlayer)
  1496 	{
  1497 		return pContext->ThrowNativeError("Client index %d is invalid", client);
  1498 	}
  1499 	else if (!pPlayer->IsInGame()) {
  1500 		return pContext->ThrowNativeError("Client %d is not in game", client);
  1501 	}
  1502 	else if (!pPlayer->IsAuthorized())
  1503 	{
  1504 		return pContext->ThrowNativeError("Client %d is not authorized", client);
  1505 	}
  1506 
  1507 	pPlayer->NotifyPostAdminChecks();
  1508 
  1509 	return 1;
  1510 }
  1511 
  1512 static cell_t IsClientInKickQueue(IPluginContext *pContext, const cell_t *params)
  1513 {
  1514 	int client = params[1];
  1515 
  1516 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
  1517 
  1518 	if (!pPlayer)
  1519 	{
  1520 		return pContext->ThrowNativeError("Client index %d is invalid", client);
  1521 	}
  1522 	else if (!pPlayer->IsConnected())
  1523 	{
  1524 		return pContext->ThrowNativeError("Client %d is not in game", client);
  1525 	}
  1526 
  1527 	return pPlayer->IsInKickQueue() ? 1 : 0;
  1528 }
  1529 
  1530 static cell_t ProcessTargetString(IPluginContext *pContext, const cell_t *params)
  1531 {
  1532 	cmd_target_info_t info;
  1533 
  1534 	pContext->LocalToString(params[1], (char **)&info.pattern);
  1535 	info.admin = params[2];
  1536 	pContext->LocalToPhysAddr(params[3], &info.targets);
  1537 	info.max_targets = params[4];
  1538 	info.flags = params[5];
  1539 	pContext->LocalToString(params[6], &info.target_name);
  1540 	info.target_name_maxlength = params[7];
  1541 
  1542 	cell_t *tn_is_ml;
  1543 	pContext->LocalToPhysAddr(params[8], &tn_is_ml);
  1544 
  1545 	g_Players.ProcessCommandTarget(&info);
  1546 
  1547 	if (info.target_name_style == COMMAND_TARGETNAME_ML)
  1548 	{
  1549 		*tn_is_ml = 1;
  1550 	}
  1551 	else
  1552 	{
  1553 		*tn_is_ml = 0;
  1554 	}
  1555 
  1556 	if (info.num_targets == 0)
  1557 	{
  1558 		return info.reason;
  1559 	}
  1560 	else
  1561 	{
  1562 		return info.num_targets;
  1563 	}
  1564 }
  1565 
  1566 static cell_t FormatActivitySource(IPluginContext *pContext, const cell_t *params)
  1567 {
  1568 	int value;
  1569 	int client;
  1570 	int target;
  1571 	CPlayer *pTarget;
  1572 	AdminId aidTarget;
  1573 	const char *identity[2] = {"Console", "ADMIN"};
  1574 
  1575 	client = params[1];
  1576 	target = params[2];
  1577 
  1578 	if ((pTarget = g_Players.GetPlayerByIndex(target)) == NULL)
  1579 	{
  1580 		return pContext->ThrowNativeError("Invalid client index %d", target);
  1581 	}
  1582 	if (!pTarget->IsConnected())
  1583 	{
  1584 		return pContext->ThrowNativeError("Client %d not connected", target);
  1585 	}
  1586 
  1587 	value = sm_show_activity.GetInt();
  1588 
  1589 	if (client != 0)
  1590 	{
  1591 		CPlayer *pPlayer;
  1592 
  1593 		if ((pPlayer = g_Players.GetPlayerByIndex(client)) == NULL)
  1594 		{
  1595 			return pContext->ThrowNativeError("Invalid client index %d", client);
  1596 		}
  1597 		if (!pPlayer->IsConnected())
  1598 		{
  1599 			return pContext->ThrowNativeError("Client %d not connected", client);
  1600 		}
  1601 
  1602 		identity[0] = pPlayer->GetName();
  1603 
  1604 		AdminId id = pPlayer->GetAdminId();
  1605 		if (id == INVALID_ADMIN_ID
  1606 			|| !g_Admins.GetAdminFlag(id, Admin_Generic, Access_Effective))
  1607 		{
  1608 			identity[1] = "PLAYER";
  1609 		}
  1610 	}
  1611 
  1612 	int mode = 1;
  1613 	bool bShowActivity = false;
  1614 
  1615 	if ((aidTarget = pTarget->GetAdminId()) == INVALID_ADMIN_ID
  1616 		|| !g_Admins.GetAdminFlag(aidTarget, Admin_Generic, Access_Effective))
  1617 	{
  1618 		/* Treat this as a normal user */
  1619 		if ((value & 1) || (value & 2))
  1620 		{
  1621 			if ((value & 2) || (target == client))
  1622 			{
  1623 				mode = 0;
  1624 			}
  1625 			bShowActivity = true;
  1626 		}
  1627 	}
  1628 	else
  1629 	{
  1630 		/* Treat this as an admin user */
  1631 		bool is_root = g_Admins.GetAdminFlag(aidTarget, Admin_Root, Access_Effective);
  1632 		if ((value & 4) 
  1633 			|| (value & 8)
  1634 			|| ((value & 16) && is_root))
  1635 		{
  1636 			if ((value & 8) || ((value & 16) && is_root) || (target == client))
  1637 			{
  1638 				mode = 0;
  1639 			}
  1640 			bShowActivity = true;
  1641 		}
  1642 	}
  1643 
  1644 	/* Otherwise, send it back to the script. */
  1645 	pContext->StringToLocalUTF8(params[3], params[4], identity[mode], NULL);
  1646 
  1647 	return bShowActivity ? 1 : 0;
  1648 }
  1649 
  1650 static cell_t sm_GetClientSerial(IPluginContext *pContext, const cell_t *params)
  1651 {
  1652 	int client = params[1];
  1653 
  1654 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
  1655 	if (!pPlayer)
  1656 	{
  1657 		return pContext->ThrowNativeError("Client index %d is invalid", client);
  1658 	}
  1659 
  1660 	return pPlayer->GetSerial();
  1661 }
  1662 
  1663 static cell_t sm_GetClientFromSerial(IPluginContext *pContext, const cell_t *params)
  1664 {
  1665 	return g_Players.GetClientFromSerial(params[1]);
  1666 }
  1667 
  1668 REGISTER_NATIVES(playernatives)
  1669 {
  1670 	{"AddUserFlags",			AddUserFlags},
  1671 	{"CanUserTarget",			CanUserTarget},
  1672 	{"ChangeClientTeam",		ChangeClientTeam},
  1673 	{"GetClientAuthString",		sm_GetClientAuthStr},
  1674 	{"GetSteamAccountID",		sm_GetSteamAccountID},
  1675 	{"GetClientCount",			sm_GetClientCount},
  1676 	{"GetClientInfo",			sm_GetClientInfo},
  1677 	{"GetClientIP",				sm_GetClientIP},
  1678 	{"GetClientName",			sm_GetClientName},
  1679 	{"GetClientTeam",			GetClientTeam},
  1680 	{"GetClientUserId",			GetClientUserId},
  1681 	{"GetMaxClients",			sm_GetMaxClients},
  1682 	{"GetMaxHumanPlayers",		sm_GetMaxHumanPlayers},
  1683 	{"GetUserAdmin",			GetUserAdmin},
  1684 	{"GetUserFlagBits",			GetUserFlagBits},
  1685 	{"IsClientAuthorized",		sm_IsClientAuthorized},
  1686 	{"IsClientConnected",		sm_IsClientConnected},
  1687 	{"IsFakeClient",			sm_IsClientFakeClient},
  1688 	{"IsClientSourceTV",		sm_IsClientSourceTV},
  1689 	{"IsClientReplay",			sm_IsClientReplay},
  1690 	{"IsClientInGame",			sm_IsClientInGame},
  1691 	{"IsClientObserver",		IsClientObserver},
  1692 	{"RemoveUserFlags",			RemoveUserFlags},
  1693 	{"SetUserAdmin",			SetUserAdmin},
  1694 	{"SetUserFlagBits",			SetUserFlagBits},
  1695 	{"GetClientDeaths",			GetDeathCount},
  1696 	{"GetClientFrags",			GetFragCount},
  1697 	{"GetClientArmor",			GetArmorValue},
  1698 	{"GetClientAbsOrigin",		GetAbsOrigin},
  1699 	{"GetClientAbsAngles",		GetAbsAngles},
  1700 	{"GetClientMins",			GetPlayerMins},
  1701 	{"GetClientMaxs",			GetPlayerMaxs},
  1702 	{"GetClientWeapon",			GetWeaponName},
  1703 	{"GetClientModel",			GetModelName},
  1704 	{"GetClientHealth",			GetHealth},
  1705 	{"GetClientTime",			GetTimeConnected},
  1706 	{"GetClientDataRate",		GetDataRate},
  1707 	{"IsClientTimingOut",		IsTimingOut},
  1708 	{"GetClientLatency",		GetLatency},
  1709 	{"GetClientAvgLatency",		GetAvgLatency},
  1710 	{"GetClientAvgLoss",		GetAvgLoss},
  1711 	{"GetClientAvgChoke",		GetAvgChoke},
  1712 	{"GetClientAvgData",		GetAvgData},
  1713 	{"GetClientAvgPackets",		GetAvgPackets},
  1714 	{"GetClientOfUserId",		GetClientOfUserId},
  1715 	{"ShowActivity",			ShowActivity},
  1716 	{"ShowActivityEx",			ShowActivityEx},
  1717 	{"ShowActivity2",			ShowActivity2},
  1718 	{"KickClient",				KickClient},
  1719 	{"KickClientEx",			KickClientEx},
  1720 	{"RunAdminCacheChecks",		RunAdminCacheChecks},
  1721 	{"NotifyPostAdminCheck",	NotifyPostAdminCheck},
  1722 	{"IsClientInKickQueue",		IsClientInKickQueue},
  1723 	{"ProcessTargetString",		ProcessTargetString},
  1724 	{"FormatActivitySource",	FormatActivitySource},
  1725 	{"GetClientSerial",			sm_GetClientSerial},
  1726 	{"GetClientFromSerial",		sm_GetClientFromSerial},
  1727 	{NULL,						NULL}
  1728 };
  1729
sourcemod-central
Feed