418 lines
10 KiB
SourcePawn
418 lines
10 KiB
SourcePawn
#pragma semicolon 1
|
|
|
|
#include <sourcemod>
|
|
|
|
#define AUTOLOAD_EXTENSIONS
|
|
#define REQUIRE_EXTENSIONS
|
|
#include <steamtools>
|
|
|
|
#define PLUGIN_VERSION "0.8.3"
|
|
|
|
public Plugin:myinfo = {
|
|
name = "SteamTools Tester",
|
|
author = "Asher Baker (asherkin)",
|
|
description = "Plugin for testing the SteamTools extension.",
|
|
version = PLUGIN_VERSION,
|
|
url = "http://limetech.org/"
|
|
};
|
|
|
|
new ReplySource:Async_GroupStatus_Reply;
|
|
new ReplySource:Async_ServerReputation_Reply;
|
|
|
|
new Async_GroupStatus_Client;
|
|
new Async_ServerReputation_Client;
|
|
|
|
new bool:HaveStats[MAXPLAYERS+1];
|
|
|
|
public OnPluginStart()
|
|
{
|
|
LoadTranslations("common.phrases");
|
|
|
|
RegAdminCmd("sm_groupstatus", Command_GroupStatus, ADMFLAG_ROOT, "Requests a client's membership status in a Steam Community Group.");
|
|
RegAdminCmd("sm_printserverreputation", Command_ServerReputation, ADMFLAG_ROOT, "Requests a server's reputation from the Steam Master Servers.");
|
|
RegAdminCmd("sm_forceheartbeat", Command_Heartbeat, ADMFLAG_ROOT, "Sends a heartbeat to the Steam Master Servers.");
|
|
RegAdminCmd("sm_printvacstatus", Command_VACStatus, ADMFLAG_ROOT, "Shows the current VAC status.");
|
|
RegAdminCmd("sm_printconnectionstatus", Command_ConnectionStatus, ADMFLAG_ROOT, "Shows the current Steam connection status.");
|
|
RegAdminCmd("sm_printip", Command_PrintIP, ADMFLAG_ROOT, "Shows the server's current external IP address.");
|
|
|
|
RegAdminCmd("sm_setrule", Command_SetRule, ADMFLAG_ROOT, "Sets (and adds if missing) the value of an entry in the Master Server Rules response.");
|
|
RegAdminCmd("sm_clearrules", Command_ClearRules, ADMFLAG_ROOT, "Removes all the entries in the Master Server Rules response.");
|
|
|
|
RegAdminCmd("sm_setgamedescription", Command_SetGameDescription, ADMFLAG_ROOT, "Sets the game description shown in the server browser.");
|
|
|
|
RegAdminCmd("sm_printstat", Command_PrintStat, ADMFLAG_ROOT, "Prints the value of a stat for a client.");
|
|
RegAdminCmd("sm_printachievement", Command_PrintAchievement, ADMFLAG_ROOT, "Prints whether or not a client has earned an achievement.");
|
|
|
|
RegAdminCmd("sm_printsubscription", Command_PrintSubscription, ADMFLAG_ROOT, "Shows the Subscription ID of the Steam Subscription that contains the client's game.");
|
|
RegAdminCmd("sm_printdlc", Command_PrintDLC, ADMFLAG_ROOT, "Shows the App IDs of the DLCs that are associated with the client's game.");
|
|
}
|
|
|
|
public OnClientAuthorized(client, const String:auth[])
|
|
{
|
|
if (!IsFakeClient(client))
|
|
{
|
|
Steam_RequestStats(client);
|
|
}
|
|
}
|
|
|
|
public OnClientDisconnect(client)
|
|
{
|
|
HaveStats[client] = false;
|
|
}
|
|
|
|
public Steam_StatsReceived(client)
|
|
{
|
|
HaveStats[client] = true;
|
|
return;
|
|
}
|
|
|
|
public Steam_StatsUnloaded(client)
|
|
{
|
|
if (client == -1) // We'll get a Steam_StatsUnloaded after a client has left.
|
|
return;
|
|
|
|
HaveStats[client] = false;
|
|
return;
|
|
}
|
|
|
|
public Action:Command_GroupStatus(client, args)
|
|
{
|
|
if (args != 2)
|
|
{
|
|
ReplyToCommand(client, "[SM] Usage: sm_groupstatus <client> <group>");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:arg1[32];
|
|
new String:arg2[32];
|
|
|
|
GetCmdArg(1, arg1, sizeof(arg1));
|
|
GetCmdArg(2, arg2, sizeof(arg2));
|
|
|
|
new String:target_name[MAX_TARGET_LENGTH];
|
|
new target_list[MAXPLAYERS], target_count;
|
|
new bool:tn_is_ml;
|
|
|
|
if ((target_count = ProcessTargetString(
|
|
arg1,
|
|
client,
|
|
target_list,
|
|
MAXPLAYERS,
|
|
COMMAND_FILTER_NO_IMMUNITY,
|
|
target_name,
|
|
sizeof(target_name),
|
|
tn_is_ml)) <= 0)
|
|
{
|
|
ReplyToTargetError(client, target_count);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new bool:didLastRequestWork = false;
|
|
|
|
for (new i = 0; i < target_count; i++)
|
|
{
|
|
didLastRequestWork = Steam_RequestGroupStatus(target_list[i], StringToInt(arg2));
|
|
}
|
|
|
|
ReplyToCommand(client, "[SM] %s.", didLastRequestWork?"Group status requested":"Error in requesting group status, not connected to Steam");
|
|
|
|
Async_GroupStatus_Client = client;
|
|
Async_GroupStatus_Reply = GetCmdReplySource();
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_ServerReputation(client, args)
|
|
{
|
|
Steam_RequestServerReputation();
|
|
ReplyToCommand(client, "[SM] Server Reputation Requested.");
|
|
|
|
Async_ServerReputation_Client = client;
|
|
Async_ServerReputation_Reply = GetCmdReplySource();
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_Heartbeat(client, args)
|
|
{
|
|
Steam_ForceHeartbeat();
|
|
ReplyToCommand(client, "[SM] Heartbeat Sent.");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_VACStatus(client, args)
|
|
{
|
|
ReplyToCommand(client, "[SM] VAC is %s.", Steam_IsVACEnabled()?"active":"not active");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_ConnectionStatus(client, args)
|
|
{
|
|
ReplyToCommand(client, "[SM] %s to Steam servers.", Steam_IsConnected()?"Connected":"Not connected");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_PrintIP(client, args)
|
|
{
|
|
new octets[4];
|
|
Steam_GetPublicIP(octets);
|
|
ReplyToCommand(client, "[SM] Server IP Address: %d.%d.%d.%d", octets[0], octets[1], octets[2], octets[3]);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_SetRule(client, args)
|
|
{
|
|
if (args != 2)
|
|
{
|
|
ReplyToCommand(client, "[SM] Usage: sm_setrule <key> <value>");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:arg1[32];
|
|
new String:arg2[32];
|
|
|
|
GetCmdArg(1, arg1, sizeof(arg1));
|
|
GetCmdArg(2, arg2, sizeof(arg2));
|
|
|
|
Steam_SetRule(arg1, arg2);
|
|
ReplyToCommand(client, "[SM] Rule Set.");
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_ClearRules(client, args)
|
|
{
|
|
Steam_ClearRules();
|
|
ReplyToCommand(client, "[SM] Rules Cleared.");
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_SetGameDescription(client, args)
|
|
{
|
|
if (args != 1)
|
|
{
|
|
ReplyToCommand(client, "[SM] Usage: sm_setgamedescription <description>");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:arg1[32];
|
|
|
|
GetCmdArg(1, arg1, sizeof(arg1));
|
|
|
|
Steam_SetGameDescription(arg1);
|
|
ReplyToCommand(client, "[SM] Game Description Set.");
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_PrintStat(client, args)
|
|
{
|
|
if (args != 2)
|
|
{
|
|
ReplyToCommand(client, "[SM] Usage: sm_printstat <client> <stat>");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:arg1[32];
|
|
new String:arg2[32];
|
|
|
|
GetCmdArg(1, arg1, sizeof(arg1));
|
|
GetCmdArg(2, arg2, sizeof(arg2));
|
|
|
|
new String:target_name[MAX_TARGET_LENGTH];
|
|
new target_list[MAXPLAYERS], target_count;
|
|
new bool:tn_is_ml;
|
|
|
|
if ((target_count = ProcessTargetString(
|
|
arg1,
|
|
client,
|
|
target_list,
|
|
MAXPLAYERS,
|
|
COMMAND_FILTER_NO_IMMUNITY,
|
|
target_name,
|
|
sizeof(target_name),
|
|
tn_is_ml)) <= 0)
|
|
{
|
|
ReplyToTargetError(client, target_count);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
for (new i = 0; i < target_count; i++)
|
|
{
|
|
if (HaveStats[client])
|
|
ReplyToCommand(client, "[SM] Stat '%s' = %d for %N.", arg2, Steam_GetStat(target_list[i], arg2), target_list[i]);
|
|
else
|
|
ReplyToCommand(client, "[SM] Stats for %N not received yet.", target_list[i]);
|
|
}
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_PrintAchievement(client, args)
|
|
{
|
|
if (args != 2)
|
|
{
|
|
ReplyToCommand(client, "[SM] Usage: sm_printachievement <client> <achievement>");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:arg1[32];
|
|
new String:arg2[32];
|
|
|
|
GetCmdArg(1, arg1, sizeof(arg1));
|
|
GetCmdArg(2, arg2, sizeof(arg2));
|
|
|
|
new String:target_name[MAX_TARGET_LENGTH];
|
|
new target_list[MAXPLAYERS], target_count;
|
|
new bool:tn_is_ml;
|
|
|
|
if ((target_count = ProcessTargetString(
|
|
arg1,
|
|
client,
|
|
target_list,
|
|
MAXPLAYERS,
|
|
COMMAND_FILTER_NO_IMMUNITY,
|
|
target_name,
|
|
sizeof(target_name),
|
|
tn_is_ml)) <= 0)
|
|
{
|
|
ReplyToTargetError(client, target_count);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
for (new i = 0; i < target_count; i++)
|
|
{
|
|
if (HaveStats[client])
|
|
ReplyToCommand(client, "[SM] %N %s earned achievement %s.", target_list[i], Steam_IsAchieved(target_list[i], arg2)?"has":"has not", arg2);
|
|
else
|
|
ReplyToCommand(client, "[SM] Stats for %N not received yet.", target_list[i]);
|
|
}
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_PrintSubscription(client, args)
|
|
{
|
|
if (args != 1)
|
|
{
|
|
ReplyToCommand(client, "[SM] Usage: sm_printsubscription <client>");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:arg1[32];
|
|
new String:arg2[32];
|
|
|
|
GetCmdArg(1, arg1, sizeof(arg1));
|
|
GetCmdArg(2, arg2, sizeof(arg2));
|
|
|
|
new String:target_name[MAX_TARGET_LENGTH];
|
|
new target_list[MAXPLAYERS], target_count;
|
|
new bool:tn_is_ml;
|
|
|
|
if ((target_count = ProcessTargetString(
|
|
arg1,
|
|
client,
|
|
target_list,
|
|
MAXPLAYERS,
|
|
COMMAND_FILTER_NO_IMMUNITY,
|
|
target_name,
|
|
sizeof(target_name),
|
|
tn_is_ml)) <= 0)
|
|
{
|
|
ReplyToTargetError(client, target_count);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
for (new i = 0; i < target_count; i++)
|
|
{
|
|
new subCount = Steam_GetNumClientSubscriptions(target_list[i]);
|
|
for (new x = 0; x < subCount; x++)
|
|
{
|
|
ReplyToCommand(client, "[SM] Client purchased this game as part of subscription %d.", Steam_GetClientSubscription(target_list[i], x));
|
|
}
|
|
}
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_PrintDLC(client, args)
|
|
{
|
|
if (args != 1)
|
|
{
|
|
ReplyToCommand(client, "[SM] Usage: sm_printdlc <client>");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:arg1[32];
|
|
new String:arg2[32];
|
|
|
|
GetCmdArg(1, arg1, sizeof(arg1));
|
|
GetCmdArg(2, arg2, sizeof(arg2));
|
|
|
|
new String:target_name[MAX_TARGET_LENGTH];
|
|
new target_list[MAXPLAYERS], target_count;
|
|
new bool:tn_is_ml;
|
|
|
|
if ((target_count = ProcessTargetString(
|
|
arg1,
|
|
client,
|
|
target_list,
|
|
MAXPLAYERS,
|
|
COMMAND_FILTER_NO_IMMUNITY,
|
|
target_name,
|
|
sizeof(target_name),
|
|
tn_is_ml)) <= 0)
|
|
{
|
|
ReplyToTargetError(client, target_count);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
for (new i = 0; i < target_count; i++)
|
|
{
|
|
new subCount = Steam_GetNumClientDLCs(target_list[i]);
|
|
for (new x = 0; x < subCount; x++)
|
|
{
|
|
ReplyToCommand(client, "[SM] Client has DLC %d.", Steam_GetClientDLC(target_list[i], x));
|
|
}
|
|
}
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Steam_GroupStatusResult(client, groupAccountID, bool:groupMember, bool:groupOfficer)
|
|
{
|
|
SetCmdReplySource(Async_GroupStatus_Reply);
|
|
ReplyToCommand(Async_GroupStatus_Client, "[SM] %N is %s in group %d.", client, groupMember?(groupOfficer?"an officer":"a member"):"not a member", groupAccountID);
|
|
Async_GroupStatus_Reply = SM_REPLY_TO_CONSOLE;
|
|
Async_GroupStatus_Client = 0;
|
|
return;
|
|
}
|
|
|
|
public Steam_Reputation(reputationScore, bool:banned, bannedIP, bannedPort, bannedGameID, banExpires)
|
|
{
|
|
SetCmdReplySource(Async_ServerReputation_Reply);
|
|
ReplyToCommand(Async_ServerReputation_Client, "[SM] Reputation Score: %d. Banned: %s.", reputationScore, banned?"true":"false");
|
|
Async_ServerReputation_Reply = SM_REPLY_TO_CONSOLE;
|
|
Async_ServerReputation_Client = 0;
|
|
return;
|
|
}
|
|
|
|
public Action:Steam_RestartRequested()
|
|
{
|
|
PrintToServer("[SM] Server needs to be restarted due to an update.");
|
|
return Plugin_Continue;
|
|
}
|
|
|
|
public Steam_SteamServersConnected()
|
|
{
|
|
PrintToChatAll("[SM] Connection to Steam servers established.");
|
|
return;
|
|
}
|
|
|
|
public Steam_SteamServersDisconnected()
|
|
{
|
|
PrintToChatAll("[SM] Lost connection to Steam servers.");
|
|
return;
|
|
}
|