public override void OnCommand(CommandArguments command)
{
if (command.Message.Length == 0)
{
CommandHandler.ReplyToCommand(command, "Usage:{0} servers <filter> - See https://developer.valvesoftware.com/wiki/Master_Server_Query_Protocol", Colors.OLIVE);
return;
}
if (command.Message.IndexOf('\\') == -1)
{
CommandHandler.ReplyToCommand(command, "That doesn't look like a filter.");
return;
}
var request = new CGameServers_GetServerList_Request
{
filter = command.Message,
limit = 5000,
};
JobManager.AddJob(
() => GameServers.SendMessage(api => api.GetServerList(request)),
new JobManager.IRCRequest
{
Type = JobManager.IRCRequestType.TYPE_GAMESERVERS,
Command = command
}
);
}
public static void OnServiceMethod(SteamUnifiedMessages.ServiceMethodResponse callback, JobManager.IRCRequest request)
{
var response = callback.GetDeserializedResponse <CGameServers_GetServerList_Response>();
var servers = response.servers;
if (!servers.Any())
{
CommandHandler.ReplyToCommand(request.Command, "No servers.");
return;
}
if (servers.Count == 1)
{
var server = servers.First();
CommandHandler.ReplyToCommand(request.Command, "{0} - {1} - {2}/{3} - Map: {4} - AppID: {5} - Version: {6} - Dir: {7} - Tags: {8} - Name: {9}",
server.addr, new SteamID(server.steamid).Render(true), server.players, server.max_players, server.map, server.appid, server.version, server.gamedir, server.gametype, server.name
);
return;
}
var serv = servers.Take(5).Select(x => string.Format("{0} ({1})", x.addr, x.players));
CommandHandler.ReplyToCommand(request.Command, "{0}{1}", string.Join(", ", serv), servers.Count > 5 ? string.Format(", and {0}{1} more", servers.Count == 5000 ? ">" : "", servers.Count - 5) : "");
}
public override async void OnCommand(CommandArguments command)
{
if (command.Message.Length == 0)
{
CommandHandler.ReplyToCommand(command, "Usage:{0} ugc <ugcid>", Colors.OLIVE);
return;
}
ulong ugcId;
if (!ulong.TryParse(command.Message, out ugcId))
{
CommandHandler.ReplyToCommand(command, "Invalid UGC ID");
return;
}
var callback = await Cloud.RequestUGCDetails(ugcId);
if (callback.Result != EResult.OK)
{
CommandHandler.ReplyToCommand(command, "Unable to request UGC info: {0}{1}", Colors.RED, callback.Result);
return;
}
CommandHandler.ReplyToCommand(command, "Creator: {0}{1}{2}, App: {3}{4}{5}, File: {6}{7}{8}, Size: {9}{10}{11} -{12} {13}",
Colors.BLUE, callback.Creator.Render(true), Colors.NORMAL,
Colors.BLUE, callback.AppID, Colors.NORMAL,
Colors.BLUE, callback.FileName, Colors.NORMAL,
Colors.BLUE, GetByteSizeString(callback.FileSize), Colors.NORMAL,
Colors.DARKBLUE, callback.URL
);
}
private void OnUGCInfo(SteamCloud.UGCDetailsCallback callback)
{
JobAction job;
if (!JobManager.TryRemoveJob(callback.JobID, out job) || !job.IsCommand)
{
return;
}
var request = job.CommandRequest;
if (callback.Result != EResult.OK)
{
CommandHandler.ReplyToCommand(request.Command, "Unable to request UGC info: {0}", callback.Result);
return;
}
CommandHandler.ReplyToCommand(request.Command, "Creator: {0}{1}{2}, App: {3}{4}{5}, File: {6}{7}{8}, Size: {9}{10}{11} -{12} {13}",
Colors.BLUE, callback.Creator.Render(true), Colors.NORMAL,
Colors.BLUE, callback.AppID, Colors.NORMAL,
Colors.BLUE, callback.FileName, Colors.NORMAL,
Colors.BLUE, GetByteSizeString(callback.FileSize), Colors.NORMAL,
Colors.DARKBLUE, callback.URL
);
}
public static void Reload(CommandArguments command)
{
Reload();
command.ReplyAsNotice = true;
CommandHandler.ReplyToCommand(command, "Reloaded {0} token overrides", SecretTokens.Count);
}
public static void ReloadImportant(CommandArguments command)
{
ReloadImportant();
command.ReplyAsNotice = true;
CommandHandler.ReplyToCommand(command, "Reloaded {0} important apps and {1} packages", ImportantApps.Count, ImportantSubs.Count);
}
private void OnServiceMethod(SteamUnifiedMessages.ServiceMethodResponse callback)
{
JobAction job;
if (!JobManager.TryRemoveJob(callback.JobID, out job) || !job.IsCommand)
{
return;
}
var request = job.CommandRequest;
if (callback.Result != EResult.OK)
{
CommandHandler.ReplyToCommand(request.Command, "Unable to make service request: {0}", callback.Result);
return;
}
// .chat about grate
switch (request.Type)
{
case JobManager.IRCRequestType.TYPE_GAMESERVERS:
ServersCommand.OnServiceMethod(callback, request);
return;
case JobManager.IRCRequestType.TYPE_PUBFILE:
case JobManager.IRCRequestType.TYPE_PUBFILE_SILENT:
PubFileCommand.OnServiceMethod(callback, request);
return;
}
CommandHandler.ReplyToCommand(request.Command, "Unknown request type, I don't know what to do.");
}
public override void OnCommand(CommandArguments command)
{
if (command.Message.Length == 0)
{
CommandHandler.ReplyToCommand(command, "Usage:{0} gid <globalid>", Colors.OLIVE);
return;
}
ulong uGid;
if (!ulong.TryParse(command.Message, out uGid))
{
CommandHandler.ReplyToCommand(command, "Invalid GlobalID.");
return;
}
GlobalID gid = uGid;
CommandHandler.ReplyToCommand(command, "{0} (SeqCount: {1}{2}{3}, StartTime: {4}{5}{6}, ProcessID: {7}{8}{9}, BoxID: {10}{11}{12})",
(ulong)gid,
Colors.LIGHTGRAY, gid.SequentialCount, Colors.NORMAL,
Colors.LIGHTGRAY, gid.StartTime, Colors.NORMAL,
Colors.LIGHTGRAY, gid.ProcessID, Colors.NORMAL,
Colors.LIGHTGRAY, gid.BoxID, Colors.NORMAL
);
}
public override void OnCommand(CommandArguments command)
{
if (command.Message.Length == 0)
{
CommandHandler.ReplyToCommand(command, "Usage:{0} ugc <ugcid>", Colors.OLIVE);
return;
}
ulong ugcId;
if (!ulong.TryParse(command.Message, out ugcId))
{
CommandHandler.ReplyToCommand(command, "Invalid UGC ID");
return;
}
JobManager.AddJob(
() => Cloud.RequestUGCDetails(ugcId),
new JobManager.IRCRequest
{
Command = command
}
);
}
public override void OnCommand(CommandArguments command)
{
BlogPost post;
using (var db = Database.GetConnection())
{
if (command.Message.Length > 0)
{
post = db.Query <BlogPost>("SELECT `ID`, `Slug`, `Title` FROM `Blog` WHERE `IsHidden` = 0 AND (`Slug` = @Slug OR `ID` = @Slug) LIMIT 1", new { Slug = command.Message }).SingleOrDefault();
}
else
{
post = db.Query <BlogPost>("SELECT `ID`, `Slug`, `Title` FROM `Blog` WHERE `IsHidden` = 0 ORDER BY `Time` DESC LIMIT 1").SingleOrDefault();
}
}
if (post.ID == 0)
{
CommandHandler.ReplyToCommand(command, "No blog post found.");
return;
}
CommandHandler.ReplyToCommand(
command,
command.Message.Length > 0 ?
"Blog post:{0} {1}{2} -{3} {4}" :
"Latest blog post:{0} {1}{2} -{3} {4}",
Colors.BLUE, post.Title, Colors.NORMAL,
Colors.DARKBLUE, SteamDB.GetBlogURL(post.Slug.Length > 0 ? post.Slug : post.ID.ToString())
);
}
private static void OnPersonaState(SteamFriends.PersonaStateCallback callback)
{
JobAction job;
if (!JobManager.TryRemoveJob(new JobID(callback.FriendID), out job) || !job.IsCommand)
{
return;
}
var command = job.CommandRequest.Command;
if (callback.FriendID.IsClanAccount)
{
var clantag = string.IsNullOrEmpty(callback.ClanTag) ? string.Empty : string.Format(" {0}(Clan tag: {1}{2}{3})",
Colors.NORMAL, Colors.LIGHTGRAY, callback.ClanTag, Colors.NORMAL);
CommandHandler.ReplyToCommand(command, "{0}{1}{2} -{3} https://steamcommunity.com/gid/{4}/{5}",
Colors.BLUE, callback.Name, Colors.NORMAL,
Colors.DARKBLUE, callback.FriendID.ConvertToUInt64(), clantag
);
}
else if (callback.FriendID.IsIndividualAccount)
{
CommandHandler.ReplyToCommand(command, "{0}{1}{2} -{3} https://steamcommunity.com/profiles/{4}/ {5}(Last login: {6}, Last logoff: {7})",
Colors.BLUE, callback.Name, Colors.NORMAL,
Colors.DARKBLUE, callback.FriendID.ConvertToUInt64(),
Colors.DARKGRAY, callback.LastLogOn, callback.LastLogOff
);
}
else
{
CommandHandler.ReplyToCommand(command, callback.Name);
}
}
private static void OnNumberOfPlayers(SteamUserStats.NumberOfPlayersCallback callback)
{
JobAction job;
if (!JobManager.TryRemoveJob(callback.JobID, out job) || !job.IsCommand)
{
return;
}
var request = job.CommandRequest;
if (callback.Result != EResult.OK)
{
CommandHandler.ReplyToCommand(request.Command, "Unable to request player count: {0}{1}", Colors.RED, callback.Result);
}
else if (request.Target == 0)
{
CommandHandler.ReplyToCommand(
request.Command,
"{0}{1:N0}{2} people praising lord Gaben right now, influence:{3} {4}",
Colors.OLIVE, callback.NumPlayers, Colors.NORMAL,
Colors.DARKBLUE, SteamDB.GetAppURL(753, "graphs")
);
}
else
{
CommandHandler.ReplyToCommand(
request.Command,
"People playing {0}{1}{2} right now: {3}{4:N0}{5} -{6} {7}",
Colors.BLUE, Steam.GetAppName(request.Target), Colors.NORMAL,
Colors.OLIVE, callback.NumPlayers, Colors.NORMAL,
Colors.DARKBLUE, SteamDB.GetAppURL(request.Target, "graphs")
);
}
}
public void ReloadImportant(CommandHandler.CommandArguments command = null)
{
using (MySqlDataReader Reader = DbWorker.ExecuteReader("SELECT `AppID` FROM `ImportantApps` WHERE `Announce` = 1"))
{
ImportantApps.Clear();
while (Reader.Read())
{
ImportantApps.Add(Reader.GetUInt32("AppID"));
}
}
using (MySqlDataReader Reader = DbWorker.ExecuteReader("SELECT `SubID` FROM `ImportantSubs`"))
{
ImportantSubs.Clear();
while (Reader.Read())
{
ImportantSubs.Add(Reader.GetUInt32("SubID"));
}
}
if (command == null)
{
Log.WriteInfo("IRC Proxy", "Loaded {0} important apps and {1} packages", ImportantApps.Count, ImportantSubs.Count);
}
else
{
CommandHandler.ReplyToCommand(command, "{0}{1}{2}: Reloaded {3} important apps and {4} packages", Colors.OLIVE, command.Nickname, Colors.NORMAL, ImportantApps.Count, ImportantSubs.Count);
}
}
public override void OnCommand(CommandArguments command)
{
if (command.Message.Length == 0)
{
CommandHandler.ReplyToCommand(command, "Usage:{0} app <appid or partial game name>", Colors.OLIVE);
return;
}
var count = PICSProductInfo.ProcessedApps.Count;
if (count > 100)
{
CommandHandler.ReplyToCommand(command, "There are currently {0} apps awaiting to be processed, try again later.", count);
return;
}
uint appID;
if (!uint.TryParse(command.Message, out appID))
{
string name = command.Message;
if (!Utils.ConvertUserInputToSQLSearch(ref name))
{
CommandHandler.ReplyToCommand(command, "Your request is invalid or too short.");
return;
}
using (var db = Database.GetConnection())
{
appID = db.ExecuteScalar <uint>("SELECT `AppID` FROM `Apps` WHERE `Apps`.`StoreName` LIKE @Name OR `Apps`.`Name` LIKE @Name OR `Apps`.`LastKnownName` LIKE @Name ORDER BY `LastUpdated` DESC LIMIT 1", new { Name = name });
}
if (appID == 0)
{
CommandHandler.ReplyToCommand(command, "Nothing was found matching your request.");
return;
}
}
var apps = new List <uint>();
apps.Add(appID);
JobManager.AddJob(
() => Steam.Instance.Apps.PICSGetAccessTokens(apps, Enumerable.Empty <uint>()),
new JobManager.IRCRequest
{
Target = appID,
Type = JobManager.IRCRequestType.TYPE_APP,
Command = command
}
);
}
void RunForEnum <TEnum>(string inputValue, CommandArguments command, bool includeDeprecated)
where TEnum : struct
{
string enumName = GetDottedTypeName(typeof(TEnum));
TEnum enumValue;
if (Enum.TryParse(inputValue, out enumValue))
{
CommandHandler.ReplyToCommand(command, "{0}{1}{2} ({3}) ={4} {5}", Colors.LIGHTGRAY, enumName, Colors.NORMAL, Enum.Format(typeof(TEnum), enumValue, "D"), Colors.BLUE, ExpandEnumFlagsToString(enumValue));
return;
}
var enumValues = Enum.GetValues(typeof(TEnum)).Cast <TEnum>();
if (!includeDeprecated)
{
enumValues = enumValues.Except(enumValues.Where(x => typeof(TEnum).GetMember(x.ToString())[0].GetCustomAttributes(typeof(ObsoleteAttribute), false).Any()));
}
if (!string.IsNullOrEmpty(inputValue))
{
enumValues = enumValues.Where(x => x.ToString().IndexOf(inputValue, StringComparison.InvariantCultureIgnoreCase) >= 0);
}
var count = enumValues.Count();
if (count == 0)
{
CommandHandler.ReplyToCommand(command, "No matches found.");
return;
}
if (count > 10)
{
if (!string.IsNullOrEmpty(inputValue))
{
CommandHandler.ReplyToCommand(command, "More than 10 results found.");
return;
}
enumValues = enumValues.Take(10);
}
var formatted = string.Join(", ", enumValues.Select(@enum => string.Format("{0}{1}{2} ({3})", Colors.BLUE, @enum.ToString(), Colors.NORMAL, Enum.Format(typeof(TEnum), @enum, "D"))));
if (count > 10)
{
formatted = string.Format("{0}, and {1} more...", formatted, count - 10);
}
CommandHandler.ReplyToCommand(command, "{0}{1}{2}: {3}", Colors.LIGHTGRAY, enumName, Colors.NORMAL, formatted);
}
private static void PrintBinary(CommandArguments command, KeyValue kv, string key)
{
if (kv[key].Children.Count == 0)
{
return;
}
kv = kv[key];
CommandHandler.ReplyToCommand(command, "{0}{1} {2}({3} MB)", CDN, kv["file"].AsString(), Colors.DARKGRAY, (kv["size"].AsLong() / 1048576.0).ToString("0.###"));
}
public static void CancelChatJobsIfAny()
{
var jobs = Jobs.Where(job => job.Value.IsCommand).ToList();
JobAction dummy;
foreach (var job in jobs)
{
CommandHandler.ReplyToCommand(job.Value.CommandRequest.Command, true, "Your request failed.");
Jobs.TryRemove(job.Key, out dummy);
}
}
public override void OnCommand(CommandArguments command)
{
if (command.Message.Length > 0)
{
return;
}
// TODO: Correctly include commands for admins if an admin uses the command
var commands = Commands
.Where(cmd => !cmd.IsAdminCommand && cmd != this)
.Select(cmd => cmd.Trigger);
CommandHandler.ReplyToCommand(command, true, "Available commands: {0}{1}", Colors.OLIVE, string.Join(string.Format("{0}, {1}", Colors.NORMAL, Colors.OLIVE), commands));
}
public override async void OnCommand(CommandArguments command)
{
if (command.Message.Length == 0)
{
CommandHandler.ReplyToCommand(command, "Usage:{0} servers <filter> - See https://developer.valvesoftware.com/wiki/Master_Server_Query_Protocol", Colors.OLIVE);
return;
}
if (command.Message.IndexOf('\\') == -1)
{
CommandHandler.ReplyToCommand(command, "That doesn't look like a filter.");
return;
}
var request = new CGameServers_GetServerList_Request
{
filter = command.Message,
limit = 5000,
};
var callback = await GameServers.SendMessage(api => api.GetServerList(request));
var response = callback.GetDeserializedResponse <CGameServers_GetServerList_Response>();
var servers = response.servers;
if (!servers.Any())
{
CommandHandler.ReplyToCommand(command, "No servers.");
return;
}
if (servers.Count == 1)
{
var server = servers.First();
CommandHandler.ReplyToCommand(command, "{0} - {1} - {2}/{3} - Map: {4} - AppID: {5} - Version: {6} - Dir: {7} - Tags: {8} - Name: {9}",
server.addr, new SteamID(server.steamid).Render(true), server.players, server.max_players, server.map, server.appid, server.version, server.gamedir, server.gametype, server.name
);
return;
}
var serv = servers.Take(5).Select(x => string.Format("{0} ({1})", x.addr, x.players));
CommandHandler.ReplyToCommand(command, "{0}{1}", string.Join(", ", serv), servers.Count > 5 ? string.Format(", and {0}{1} more", servers.Count == 5000 ? ">" : "", servers.Count - 5) : "");
}
private static void RemoveStaleJobs()
{
var jobs = Jobs.Where(job => job.Value.IsCommand && DateTime.Now >= job.Value.CommandRequest.ExpireTime).ToList();
JobAction dummy;
foreach (var job in jobs)
{
Log.WriteDebug("Job Manager", "Timed out job: {0} ({1} jobs left)", job.Key, Jobs.Count);
CommandHandler.ReplyToCommand(job.Value.CommandRequest.Command, true, "Your request timed out.");
Jobs.TryRemove(job.Key, out dummy);
}
}
public override void OnCommand(CommandArguments command)
{
if (command.Message.Length == 0)
{
CommandHandler.ReplyToCommand(command, "Usage:{0} bins <{1}> [stable (returns publicbeta by default)]", Colors.OLIVE, string.Join("/", Systems));
return;
}
var args = command.Message.Split(' ');
string os = args[0];
if (!Systems.Contains(os))
{
CommandHandler.ReplyToCommand(command, "Invalid OS. Valid ones are: {0}", string.Join(", ", Systems));
return;
}
using (var webClient = new WebClient())
{
webClient.DownloadDataCompleted += delegate(object sender, DownloadDataCompletedEventArgs e)
{
var kv = new KeyValue();
using (var ms = new MemoryStream(e.Result))
{
try
{
kv.ReadAsText(ms);
}
catch
{
CommandHandler.ReplyToCommand(command, "Something went horribly wrong and keyvalue parser died.");
return;
}
}
PrintBinary(command, kv, string.Concat("bins_", os));
PrintBinary(command, kv, string.Concat("bins_client_", os));
};
var isStable = args.Length > 1 && args[1].Equals("stable");
webClient.DownloadDataAsync(new Uri(string.Format("{0}steam_client_{1}{2}?_={3}", CDN, isStable ? "" : "publicbeta_", os, DateTime.UtcNow.Ticks)));
}
}
public override void OnCommand(CommandArguments command)
{
if (command.Message.Length == 0)
{
CommandHandler.ReplyToCommand(command, "Usage:{0} players <appid or partial game name>", Colors.OLIVE);
CommandHandler.ReplyToCommand(command, true, "Use {0}^{1} and {2}${3} just like in regex to narrow down your match, e.g:{4} !players Portal$", Colors.BLUE, Colors.NORMAL, Colors.BLUE, Colors.NORMAL, Colors.OLIVE);
return;
}
uint appID;
if (!uint.TryParse(command.Message, out appID))
{
string name = command.Message;
if (!Utils.ConvertUserInputToSQLSearch(ref name))
{
CommandHandler.ReplyToCommand(command, "Your request is invalid or too short.");
return;
}
using (var db = Database.GetConnection())
{
appID = db.ExecuteScalar <uint>("SELECT `AppID` FROM `Apps` LEFT JOIN `AppsTypes` ON `Apps`.`AppType` = `AppsTypes`.`AppType` WHERE (`AppsTypes`.`Name` IN ('game', 'application') AND (`Apps`.`StoreName` LIKE @Name OR `Apps`.`Name` LIKE @Name)) OR (`AppsTypes`.`Name` = 'unknown' AND `Apps`.`LastKnownName` LIKE @Name) ORDER BY `LastUpdated` DESC LIMIT 1", new { Name = name });
}
if (appID == 0)
{
CommandHandler.ReplyToCommand(command, "Nothing was found matching your request.");
return;
}
}
JobManager.AddJob(
() => Steam.Instance.UserStats.GetNumberOfCurrentPlayers(appID),
new JobManager.IRCRequest
{
Target = appID,
Command = command
}
);
}
public override async void OnCommand(CommandArguments command)
{
if (command.Message.Length == 0)
{
CommandHandler.ReplyToCommand(command, "Usage:{0} bins <{1}> [stable (returns publicbeta by default)]", Colors.OLIVE, string.Join("/", Systems));
return;
}
var args = command.Message.Split(' ');
string os = args[0];
if (os == "windows")
{
os = "win32";
}
else if (os == "linux")
{
os = "ubuntu12";
}
if (!Systems.Contains(os))
{
CommandHandler.ReplyToCommand(command, "Invalid OS. Valid ones are: {0}", string.Join(", ", Systems));
return;
}
using (var webClient = new WebClient())
{
var isStable = args.Length > 1 && args[1].Equals("stable");
string data = await webClient.DownloadStringTaskAsync(new Uri(string.Format("{0}steam_client_{1}{2}?_={3}", CDN, isStable ? "" : "publicbeta_", os, DateTime.UtcNow.Ticks)));
var kv = KeyValue.LoadFromString(data);
if (kv == null)
{
throw new Exception("Failed to parse downloaded client manifest.");
}
PrintBinary(command, kv, string.Concat("bins_", os));
PrintBinary(command, kv, string.Concat("bins_client_", os));
}
}
public override async void OnCommand(CommandArguments command)
{
uint subID;
if (command.Message.Length == 0 || !uint.TryParse(command.Message, out subID))
{
CommandHandler.ReplyToCommand(command, "Usage:{0} sub <subid>", Colors.OLIVE);
return;
}
var count = PICSProductInfo.ProcessedSubs.Count;
if (count > 100)
{
CommandHandler.ReplyToCommand(command, "There are currently {0} packages awaiting to be processed, try again later.", count);
return;
}
var job = await Steam.Instance.Apps.PICSGetProductInfo(null, subID, false, false);
var callback = job.Results.First(x => !x.ResponsePending);
if (!callback.Packages.ContainsKey(subID))
{
CommandHandler.ReplyToCommand(command, "Unknown SubID: {0}{1}{2}", Colors.BLUE, subID, LicenseList.OwnedSubs.ContainsKey(subID) ? SteamDB.StringCheckmark : string.Empty);
return;
}
var info = callback.Packages[subID];
info.KeyValues.SaveToFile(Path.Combine(Application.Path, "sub", string.Format("{0}.vdf", info.ID)), false);
CommandHandler.ReplyToCommand(command, "{0}{1}{2} -{3} {4}{5} - Dump:{6} {7}{8}{9}{10}",
Colors.BLUE, Steam.GetPackageName(info.ID), Colors.NORMAL,
Colors.DARKBLUE, SteamDB.GetPackageURL(info.ID), Colors.NORMAL,
Colors.DARKBLUE, SteamDB.GetRawPackageURL(info.ID), Colors.NORMAL,
info.MissingToken ? SteamDB.StringNeedToken : string.Empty,
LicenseList.OwnedSubs.ContainsKey(info.ID) ? SteamDB.StringCheckmark : string.Empty
);
}
private void OnDisconnected(SteamClient.DisconnectedCallback callback)
{
if (!IsRunning)
{
Timer.Stop();
Log.WriteInfo("Steam", "Disconnected from Steam");
return;
}
if (Timer.Enabled)
{
IRC.SendMain("Disconnected from Steam. See{0} http://steamstat.us", Colors.DARK_BLUE);
}
Timer.Stop();
GameCoordinator.UpdateStatus(0, EResult.NoConnection.ToString());
if (SteamProxy.Instance.IRCRequests.Count > 0)
{
foreach (var request in SteamProxy.Instance.IRCRequests)
{
CommandHandler.ReplyToCommand(request.Command, "{0}{1}{2}: Your request failed.", Colors.OLIVE, request.Command.Nickname, Colors.NORMAL);
}
SteamProxy.Instance.IRCRequests.Clear();
}
const uint RETRY_DELAY = 15;
Log.WriteInfo("Steam", "Disconnected from Steam. Retrying in {0} seconds...", RETRY_DELAY);
IRC.SendEmoteAnnounce("disconnected from Steam. Retrying in {0} seconds...", RETRY_DELAY);
Thread.Sleep(TimeSpan.FromSeconds(RETRY_DELAY));
Client.Connect();
}
public void OnNumberOfPlayers(SteamUserStats.NumberOfPlayersCallback callback, JobID jobID)
{
var request = IRCRequests.Find(r => r.JobID == jobID);
if (request == null)
{
return;
}
IRCRequests.Remove(request);
if (callback.Result != EResult.OK)
{
CommandHandler.ReplyToCommand(request.Command, "{0}{1}{2}: Unable to request player count: {3}", Colors.OLIVE, request.Command.Nickname, Colors.NORMAL, callback.Result);
}
else if (request.Target == 0)
{
CommandHandler.ReplyToCommand(request.Command, "{0}{1}{2}: {3}{4:N0}{5} people praising lord Gaben right now, influence:{6} {7}", Colors.OLIVE, request.Command.Nickname, Colors.NORMAL, Colors.OLIVE, callback.NumPlayers, Colors.NORMAL, Colors.DARK_BLUE, SteamDB.GetGraphURL(0));
}
else
{
string graphUrl = string.Empty;
string name = GetAppName(request.Target);
using (MySqlDataReader Reader = DbWorker.ExecuteReader("SELECT `AppID` FROM `ImportantApps` WHERE (`Graph` = 1 OR `MaxPlayers` > 0) AND `AppID` = @AppID", new MySqlParameter("AppID", request.Target)))
{
if (Reader.Read())
{
graphUrl = string.Format("{0} -{1} {2}", Colors.NORMAL, Colors.DARK_BLUE, SteamDB.GetGraphURL(request.Target));
}
}
CommandHandler.ReplyToCommand(request.Command, "{0}{1}{2}: People playing {3}{4}{5} right now: {6}{7:N0}{8} -{9} {10}{11}",
Colors.OLIVE, request.Command.Nickname, Colors.NORMAL,
Colors.OLIVE, name, Colors.NORMAL,
Colors.GREEN, callback.NumPlayers, Colors.NORMAL,
Colors.DARK_BLUE, SteamDB.GetAppURL(request.Target), graphUrl);
}
}
public override void OnCommand(CommandArguments command)
{
if (command.Message.Length == 0)
{
CommandHandler.ReplyToCommand(command, "Usage:{0} pubfile <pubfileid>", Colors.OLIVE);
return;
}
ulong pubFileId;
if (!ulong.TryParse(command.Message, out pubFileId))
{
CommandHandler.ReplyToCommand(command, "Invalid Published File ID");
return;
}
var pubFileRequest = new CPublishedFile_GetDetails_Request
{
includeadditionalpreviews = true,
includetags = true,
includekvtags = true,
includevotes = true,
//includeforsaledata = true, // TODO: Needs updated steamkit
};
pubFileRequest.publishedfileids.Add(pubFileId);
JobManager.AddJob(
() => PublishedFiles.SendMessage(api => api.GetDetails(pubFileRequest)),
new JobManager.IRCRequest
{
Type = JobManager.IRCRequestType.TYPE_PUBFILE,
Command = command
}
);
}
public override void OnCommand(CommandArguments command)
{
if (command.Message.Equals("list", StringComparison.CurrentCultureIgnoreCase))
{
CommandHandler.ReplyToCommand(command, string.Join(", ", SteamKitEnums.Select(@enum => @enum.Name)));
return;
}
var args = command.Message.Split(' ');
if (args.Length < 1)
{
CommandHandler.ReplyToCommand(command, "Usage:{0} enum <enumname> [value or substring [deprecated]]", Colors.OLIVE);
return;
}
var enumType = args[0].Replace("SteamKit2.", "");
var matchingEnumType = SteamKitEnums
.FirstOrDefault(x => x.Name.Equals(enumType, StringComparison.InvariantCultureIgnoreCase) || GetDottedTypeName(x).IndexOf(enumType, StringComparison.OrdinalIgnoreCase) != -1);
if (matchingEnumType == null)
{
CommandHandler.ReplyToCommand(command, "No such enum type.");
return;
}
bool includeDeprecated = args.Length > 2 && args[2].Equals("deprecated", StringComparison.InvariantCultureIgnoreCase);
GetType().GetMethod("RunForEnum", BindingFlags.Instance | BindingFlags.NonPublic)
.MakeGenericMethod(matchingEnumType)
.Invoke(this, new object[] { args.Length > 1 ? args[1] : string.Empty, command, includeDeprecated });
}
public void OnChatMessage(SteamFriends.ChatMsgCallback callback)
{
if (callback.ChatMsgType != EChatEntryType.ChatMsg || callback.Message[0] != '!' || callback.Message.Contains('\n'))
{
return;
}
var i = callback.Message.IndexOf(' ');
var inputCommand = i == -1 ? callback.Message : callback.Message.Substring(0, i);
Action <CommandHandler.CommandArguments> callbackFunction;
if (CommandHandler.Commands.TryGetValue(inputCommand, out callbackFunction))
{
var input = i == -1 ? string.Empty : callback.Message.Substring(i).Trim();
var command = new CommandHandler.CommandArguments
{
SenderID = callback.ChatterID,
ChatRoomID = callback.ChatRoomID,
Nickname = Steam.Instance.Friends.GetFriendPersonaName(callback.ChatterID),
Message = input
};
if (SteamDB.IsBusy())
{
CommandHandler.ReplyToCommand(command, "{0}{1}{2}: The bot is currently busy.", Colors.OLIVE, command.Nickname, Colors.NORMAL);
return;
}
Log.WriteInfo("Steam", "Handling command {0} for user {1} in chatroom {2}", inputCommand, callback.ChatterID, callback.ChatRoomID);
callbackFunction(command);
}
}
public override void OnCommand(CommandArguments command)
{
if (command.Message.Length == 0)
{
CommandHandler.ReplyToCommand(command, "Usage:{0} steamid <steamid> [individual/group/gamegroup]", Colors.OLIVE);
return;
}
var args = command.Message.Split(' ');
var urlType = EVanityURLType.Default;
if (args.Length > 1)
{
switch (args[1])
{
case "individual":
urlType = EVanityURLType.Individual;
break;
case "group":
urlType = EVanityURLType.Group;
break;
case "game":
case "gamegroup":
urlType = EVanityURLType.OfficialGameGroup;
break;
default:
CommandHandler.ReplyToCommand(command, "Invalid vanity url type.");
return;
}
}
SteamID steamID;
if (urlType != EVanityURLType.Default || !TrySetSteamID(args[0], out steamID))
{
if (urlType == EVanityURLType.Default)
{
urlType = EVanityURLType.Individual;
}
var eResult = ResolveVanityURL(args[0], urlType, out steamID);
if (eResult != EResult.OK)
{
CommandHandler.ReplyToCommand(command, "Failed to resolve vanity url: {0}{1}", Colors.RED, eResult.ToString());
return;
}
}
CommandHandler.ReplyToCommand(command, ExpandSteamID(steamID));
if (!steamID.IsValid || (!steamID.IsIndividualAccount && !steamID.IsClanAccount))
{
return;
}
JobAction job;
if (JobManager.TryRemoveJob(new JobID(steamID), out job) && job.IsCommand)
{
CommandHandler.ReplyToCommand(job.CommandRequest.Command, true, "Your !steamid request was lost in space.");
}
JobManager.AddJob(
() => FakePersonaStateJob(steamID),
new JobManager.IRCRequest
{
Command = command
}
);
}
