public async Task TF2Item(CommandContext ctx,
[Description("Item to find in the TF2 schema")][RemainingText] string query = "The Scattergun")
{
var item = TeamFortressService.GetSchemaItem(query);
if (item is null)
{
await BotServices.SendEmbedAsync(ctx, Resources.NOT_FOUND_GENERIC, EmbedType.Missing).ConfigureAwait(false);
}
else
{
var textInfo = new CultureInfo("en-US", false).TextInfo;
var output = new DiscordEmbedBuilder()
.WithTitle(item.ItemName)
.WithDescription(item.ItemDescription ?? string.Empty)
.WithImageUrl(item.ImageUrlLarge ?? item.ImageUrl)
.WithUrl("https://wiki.teamfortress.com/wiki/" + item.ItemName.Replace(' ', '_'))
.WithFooter("ID: " + item.DefIndex)
.WithColor(new DiscordColor("#E7B53B"));
var classes = new StringBuilder();
foreach (var className in item.UsedByClasses)
{
classes.Append(className).Append(!className.Equals(item.UsedByClasses.Last()) ? ", " : string.Empty);
}
output.AddField("Used by:", classes.ToString() ?? "Unknown", true);
output.AddField("Item Slot:", textInfo.ToTitleCase(item.ItemSlot) ?? "Unknown", true);
output.AddField("Item Type:", item.ItemTypeName ?? "Unknown", true);
output.AddField("Giftable:", (item.Capabilities.CanGiftWrap == true) ? "Yes" : "No", true);
output.AddField("Nameable:", (item.Capabilities.Nameable) ? "Yes" : "No", true);
output.AddField("Restriction:", item.HolidayRestriction ?? "None", true);
await ctx.RespondAsync(embed : output.Build()).ConfigureAwait(false);
}
}
public void GetServers()
{
Assert.IsNotNull(TeamFortressService
.GetServersByGameModeAsync(TestSetup.Tokens.TeamworkToken, "payload").Result);
Assert.IsNull(TeamFortressService
.GetServersByGameModeAsync(TestSetup.Tokens.TeamworkToken, "payloader").Result);
}
public async Task TF2News(CommandContext ctx)
{
var results = await TeamFortressService.GetNewsOverviewAsync().ConfigureAwait(false);
if (results is null || results.Count == 0)
{
await BotServices.SendEmbedAsync(ctx, Resources.NOT_FOUND_GENERIC, EmbedType.Missing).ConfigureAwait(false);
}
public void GetMapStats()
{
Assert.IsNotNull(TeamFortressService.GetMapStatsAsync(TestSetup.Tokens.TeamworkToken, "pl_upward")
.Result);
Assert.IsNotNull(TeamFortressService.GetMapStatsAsync(TestSetup.Tokens.TeamworkToken, "upward")
.Result);
Assert.IsNull(TeamFortressService.GetMapStatsAsync(TestSetup.Tokens.TeamworkToken, "bonewards")
.Result);
}
public async Task Update(CommandContext ctx)
{
var message = await ctx.RespondAsync("Starting update...").ConfigureAwait(false);
await SteamService.UpdateSteamListAsync().ConfigureAwait(false);
await TeamFortressService.UpdateTF2SchemaAsync().ConfigureAwait(false);
await PokemonService.UpdatePokemonListAsync().ConfigureAwait(false);
await message.ModifyAsync("Starting update...done!").ConfigureAwait(false);
}
public async Task Tf2News(CommandContext ctx,
[Description("Page number from which to retrieve the news")]
int query = 0)
{
await ctx.TriggerTypingAsync();
var results = await TeamFortressService.GetNewsArticlesAsync(Program.Settings.Tokens.TeamworkToken, query)
.ConfigureAwait(false);
if (results is null || results.Count == 0)
{
await BotServices.SendResponseAsync(ctx, Resources.NOT_FOUND_COMMON, ResponseType.Missing)
.ConfigureAwait(false);
return;
}
while (results.Count > 0)
{
var output = new DiscordEmbedBuilder()
.WithColor(new DiscordColor("#E7B53B"))
.WithFooter(results.Count - 5 >= 5
? "Type 'next' within 10 seconds for the next five posts."
: "These are all the latest posts at this time.");
foreach (var result in results.Take(5))
{
output.AddField(result.CreatedAt.Date.ToString(),
$"{result.Provider ?? result.Type}: [{result.Title}]({result.Link.AbsoluteUri})");
results.Remove(result);
}
var message = await ctx.RespondAsync("Latest news articles from teamwork.tf", output)
.ConfigureAwait(false);
if (results.Count < 5)
{
break;
}
var interactivity = await BotServices.GetUserInteractivity(ctx, "next", 10).ConfigureAwait(false);
if (interactivity.Result is null)
{
break;
}
await BotServices.RemoveMessage(interactivity.Result).ConfigureAwait(false);
await BotServices.RemoveMessage(message).ConfigureAwait(false);
}
}
public async Task Tf2ServerList(CommandContext ctx)
{
await ctx.TriggerTypingAsync();
var results = await TeamFortressService.GetCustomServerListsAsync(Program.Settings.Tokens.TeamworkToken)
.ConfigureAwait(false);
results = results.OrderBy(_ => new Random().Next()).ToList();
while (results.Count > 0)
{
var output = new DiscordEmbedBuilder()
.WithFooter("Type 'next' within 10 seconds for the next set of server lists.")
.WithColor(new DiscordColor("#E7B53B"));
foreach (var list in results.Take(4))
{
var desc = Regex.Replace(
list.DescriptionLarge.Length <= 400
? list.DescriptionLarge
: list.DescriptionLarge.Substring(0, 200) + "...", "<[^>]*>", "");
output.AddField($"Created By: {list.Creator.Name ?? "Unknown"} \t Subscribers: {list.Subscribed}",
$"[{list.Name}]({Resources.URL_TeamworkTF + list.Id}) - {desc}");
results.Remove(list);
}
var message = await ctx
.RespondAsync("Community-Curated Server Lists from teamwork.tf", output.Build())
.ConfigureAwait(false);
if (results.Count == 4)
{
continue;
}
var interactivity = await BotServices.GetUserInteractivity(ctx, "next", 10).ConfigureAwait(false);
if (interactivity.Result is null)
{
break;
}
await BotServices.RemoveMessage(interactivity.Result).ConfigureAwait(false);
await BotServices.RemoveMessage(message).ConfigureAwait(false);
}
}
public async Task Tf2Schema(CommandContext ctx,
[Description("Item to find in the TF2 schema")][RemainingText]
string query = "The Scattergun")
{
await ctx.TriggerTypingAsync();
var item = TeamFortressService.GetSchemaItem(query);
if (item is null)
{
await BotServices.SendResponseAsync(ctx, Resources.NOT_FOUND_COMMON, ResponseType.Missing)
.ConfigureAwait(false);
return;
}
var textInfo = new CultureInfo("en-US", false).TextInfo;
var output = new DiscordEmbedBuilder()
.WithTitle(item.ItemName)
.WithDescription(item.ItemDescription ?? string.Empty)
.AddField("Item Slot:", textInfo.ToTitleCase(item.ItemSlot) ?? "Unknown", true)
.AddField("Giftable:", item.Capabilities.CanGiftWrap == true ? "Yes" : "No", true)
.AddField("Nameable:", item.Capabilities.Nameable ? "Yes" : "No", true)
.WithThumbnail(item.ImageUrlLarge ?? item.ImageUrl)
.WithUrl(string.Format(Resources.URL_TF2Wiki, item.ItemName.Replace(' ', '_')))
.WithFooter("ID: " + item.DefIndex)
.WithColor(new DiscordColor("#E7B53B"));
if (item.UsedByClasses != null)
{
var classes = new StringBuilder();
foreach (var className in item.UsedByClasses)
{
classes.Append(className)
.Append(!className.Equals(item.UsedByClasses.Last()) ? ", " : string.Empty);
}
output.AddField("Used by:", classes.ToString() ?? "Unknown");
}
else
{
output.AddField("Used by:", "All-Classes");
}
await ctx.RespondAsync(output.Build()).ConfigureAwait(false);
}
public async Task Tf2ServerByIp(CommandContext ctx,
[Description("Game server IP address, like 164.132.233.16")][RemainingText]
string ip)
{
await ctx.TriggerTypingAsync();
if (string.IsNullOrWhiteSpace(ip) || !IPAddress.TryParse(ip, out var address))
{
await BotServices.SendResponseAsync(ctx, Resources.ERR_INVALID_IP, ResponseType.Missing)
.ConfigureAwait(false);
return;
}
await ctx.RespondAsync(string.Format(Resources.URL_Steam_Connect, address)).ConfigureAwait(false);
await ctx.RespondAsync(
TeamFortressService.GetServerInfo(Program.Settings.Tokens.TeamworkToken, address.ToString()))
.ConfigureAwait(false);
}
public async Task TF2Map(CommandContext ctx,
[Description("Normalized map name, like pl_upward")] string query)
{
if (!BotServices.CheckUserInput(query))
{
return;
}
var results = await TeamFortressService.GetMapStatsAsync(query.ToLowerInvariant()).ConfigureAwait(false);
if (results.Name is null)
{
await BotServices.SendEmbedAsync(ctx, Resources.NOT_FOUND_GENERIC, EmbedType.Missing).ConfigureAwait(false);
}
else
{
double.TryParse(results.AvgPlayers, out var avg_players);
var output = new DiscordEmbedBuilder()
.WithTitle(results.Name)
.AddField("Official", results.OfficialMap ? "Yes" : "No", true)
.AddField("Game Mode", results.GameModes[0] ?? "Unknown", true)
.AddField("Highest Server Count", results.HighestServerCount.ToString() ?? "Unknown", true)
.AddField("Highest Player Count", results.HighestPlayerCount.ToString() ?? "Unknown", true)
.AddField("Avg. Players", Math.Round(avg_players, 2).ToString() ?? "Unknown", true)
.WithFooter("Statistics retrieved from teamwork.tf - refreshed every 5 minutes")
.WithImageUrl(results.Thumbnail)
.WithUrl("https://wiki.teamfortress.com/wiki/" + results.Name)
.WithColor(new DiscordColor("#E7B53B"));
if (results.RelatedMaps.Count > 0)
{
var maps = new StringBuilder();
foreach (var map in results.RelatedMaps.Take(4))
{
maps.Append(map + "\n");
}
output.AddField("Related Map(s)", maps.ToString(), true);
}
await ctx.RespondAsync(embed : output.Build()).ConfigureAwait(false);
}
}
public void UpdateTf2Schema()
{
Assert.IsTrue(TeamFortressService.UpdateTf2SchemaAsync(TestSetup.Tokens.SteamToken).Result);
}
public async Task Tf2ServerByMode(CommandContext ctx,
[Description("Name of the game-mode, like payload.")][RemainingText]
string query)
{
if (string.IsNullOrWhiteSpace(query))
{
return;
}
await ctx.TriggerTypingAsync();
var results = await TeamFortressService
.GetServersByGameModeAsync(Program.Settings.Tokens.TeamworkToken, query.Trim().Replace(' ', '-'))
.ConfigureAwait(false);
if (results is null)
{
await BotServices.SendResponseAsync(ctx, Resources.NOT_FOUND_COMMON, ResponseType.Missing)
.ConfigureAwait(false);
return;
}
foreach (var server in results.OrderBy(_ => new Random().Next()).ToList())
{
var output = new DiscordEmbedBuilder()
.WithTitle(server.Name)
.WithDescription("steam://connect/" + server.Ip + ":" + server.Port)
.AddField("Provider", server.Provider != null ? server.Provider.Name : "Unknown", true)
.AddField("Player Count",
(server.Players.ToString() ?? "Unknown") + "/" + (server.MaxPlayers.ToString() ?? "Unknown"),
true)
.AddField("Password Lock", server.HasPassword ? "Yes" : "No", true)
.AddField("Random Crits", server.HasRandomCrits == true ? "Yes" : "No", true)
.AddField("Instant Respawn", server.HasNoRespawnTime ? "Yes" : "No", true)
.AddField("All Talk", server.HasAllTalk ? "Yes" : "No", true)
.AddField("Current Map", server.MapName ?? "Unknown", true)
.AddField("Next Map", server.MapNameNext ?? "Unknown", true)
.WithFooter("Type 'next' within 10 seconds for the next server.")
.WithColor(new DiscordColor("#E7B53B"));
var thumbnailUrl = await TeamFortressService
.GetMapThumbnailAsync(Program.Settings.Tokens.TeamworkToken, server.MapName).ConfigureAwait(false);
output.WithImageUrl(thumbnailUrl.Name);
var message = await ctx.RespondAsync(output.Build()).ConfigureAwait(false);
if (results.Count == 1)
{
continue;
}
var interactivity = await BotServices.GetUserInteractivity(ctx, "next", 10).ConfigureAwait(false);
if (interactivity.Result is null)
{
break;
}
if (!server.Equals(results.Last()))
{
await BotServices.RemoveMessage(message).ConfigureAwait(false);
}
await BotServices.RemoveMessage(interactivity.Result).ConfigureAwait(false);
}
}
public async Task Tf2Creators(CommandContext ctx,
[Description("Name of the community creator to find.")][RemainingText]
string query)
{
if (string.IsNullOrWhiteSpace(query))
{
return;
}
await ctx.TriggerTypingAsync();
var steamId = SteamService.GetSteamUserId(query).Result;
if (steamId is null)
{
await BotServices.SendResponseAsync(ctx, Resources.NOT_FOUND_COMMON, ResponseType.Missing)
.ConfigureAwait(false);
return;
}
var results = await TeamFortressService
.GetContentCreatorAsync(Program.Settings.Tokens.TeamworkToken, steamId.Data).ConfigureAwait(false);
if (results.Count == 0)
{
await BotServices.SendResponseAsync(ctx, Resources.NOT_FOUND_COMMON, ResponseType.Missing)
.ConfigureAwait(false);
return;
}
foreach (var creator in results)
{
var user = results.FirstOrDefault();
var output = new DiscordEmbedBuilder()
.WithTitle(user?.Name)
.WithDescription("Main Class: " + user?.Main?.ToString()?.ToUpper())
.WithThumbnail(user?.ThumbnailUrl)
.WithUrl(user?.Link)
.WithColor(new DiscordColor("#E7B53B"))
.WithFooter(!creator.Equals(results.Last())
? "Type 'next' within 10 seconds for the next creator"
: "Data retrieved from teamwork.tf");
var links = new StringBuilder();
if (creator.DiscordGroup != null)
{
links.Append($"[Discord]({Resources.URL_Discord}{creator.DiscordGroup}) **|** ");
}
if (!string.IsNullOrWhiteSpace(creator.Steam))
{
links.Append($"[Steam]({Resources.URL_Steam_User}{creator.Steam}) **|** ");
}
if (creator.SteamGroup != null)
{
links.Append($"[Steam Group]({Resources.URL_Steam_Group}{creator.SteamGroup}) **|** ");
}
if (creator.Twitch != null)
{
links.Append($"[Twitch]({Resources.URL_Twitch}{creator.Twitch}) **|** ");
}
if (!string.IsNullOrWhiteSpace(creator.Twitter))
{
links.Append($"[Twitter]({Resources.URL_Twitter}{creator.Twitter}) **|** ");
}
if (!string.IsNullOrWhiteSpace(creator.Youtube))
{
links.Append($"[YouTube]({string.Format(Resources.URL_YouTube_Channel, creator.Youtube)})");
}
output.AddField("Links", links.ToString(), true);
var message = await ctx.RespondAsync(output.Build()).ConfigureAwait(false);
if (results.Count == 1)
{
continue;
}
var interactivity = await BotServices.GetUserInteractivity(ctx, "next", 10).ConfigureAwait(false);
if (interactivity.Result is null)
{
break;
}
await BotServices.RemoveMessage(interactivity.Result).ConfigureAwait(false);
if (!creator.Equals(results.Last()))
{
await BotServices.RemoveMessage(message).ConfigureAwait(false);
}
}
}
public void UpdateTF2Schema()
{
Assert.IsTrue(TeamFortressService.UpdateTF2SchemaAsync().Result);
}
public void GetMapStats()
{
Assert.IsNotNull(TeamFortressService.GetMapStatsAsync("pl_upward").Result.Name);
Assert.IsNotNull(TeamFortressService.GetMapStatsAsync("upward").Result.Name);
Assert.IsNull(TeamFortressService.GetMapStatsAsync("onpward").Result.Name);
}
public void GetServers()
{
Assert.Greater(TeamFortressService.GetServersAsync("payload").Result.Count, 0);
Assert.Equals(TeamFortressService.GetServersAsync("payloader").Result.Count, 0);
}
public void GetSchemaItem()
{
Assert.IsNotNull(TeamFortressService.GetSchemaItem("scattergun"));
Assert.IsNull(TeamFortressService.GetSchemaItem("shattergun"));
}
public void GetNewsOverview()
{
Assert.IsNotNull(TeamFortressService.GetNewsOverviewAsync().Result);
}
public async Task Tf2Map(CommandContext ctx,
[Description("Normalized map name, like pl_upward")]
string query)
{
if (string.IsNullOrWhiteSpace(query))
{
return;
}
await ctx.TriggerTypingAsync();
var results = await TeamFortressService
.GetMapStatsAsync(Program.Settings.Tokens.TeamworkToken, query.ToLowerInvariant())
.ConfigureAwait(false);
if (results is null)
{
await BotServices.SendResponseAsync(ctx, Resources.NOT_FOUND_COMMON, ResponseType.Missing)
.ConfigureAwait(false);
return;
}
_ = double.TryParse(results.AllTimeAvgPlayers, out var avgPlayers);
var output = new DiscordEmbedBuilder()
.WithTitle(results.MapName)
.AddField("Highest Server Count", results.HighestServers.ToString() ?? "Unknown", true)
.AddField("Highest Player Count", results.HighestPlayers.ToString() ?? "Unknown", true)
.AddField("Avg. Players", Math.Round(avgPlayers, 2).ToString(CultureInfo.InvariantCulture) ?? "Unknown",
true)
.WithFooter("Statistics retrieved from teamwork.tf - refreshed every 5 minutes")
.WithImageUrl(results.Thumbnail)
.WithUrl(string.Format(Resources.URL_TF2Wiki, results.MapName))
.WithColor(new DiscordColor("#E7B53B"));
if (results.RelatedMaps.Count > 0)
{
var maps = new StringBuilder();
foreach (var map in results.RelatedMaps.Take(4))
{
maps.Append(map + "\n");
}
output.AddField("Related Map(s)", maps.ToString(), true);
}
if (results.ExtraInfo != null)
{
var links = new StringBuilder();
if (results.ExtraInfo.SteamWorkshopUrl != null)
{
links.Append($"[Steam Workshop]({results.ExtraInfo.SteamWorkshopUrl}) **|**");
}
if (results.ExtraInfo.Tf2MapsUrl != null)
{
links.Append($"[TF2Maps]({results.ExtraInfo.Tf2MapsUrl}) **|**");
}
if (results.ExtraInfo.GameBananaUrl != null)
{
links.Append($"[GameBanana]({results.ExtraInfo.GameBananaUrl}");
}
output.AddField("Links", links.ToString(), true);
}
if (results.GameModes.Count > 0)
{
var desc = TeamFortressService.GetGameModeInfoAsync(Program.Settings.Tokens.TeamworkToken,
results.GameModes.FirstOrDefault()).Result;
output.WithDescription(desc.Title + " - " + desc.Description);
output.WithColor(new DiscordColor($"#{desc.Color}"));
}
await ctx.RespondAsync(output.Build()).ConfigureAwait(false);
}
public void GetNewsOverview()
{
Assert.IsNotNull(TeamFortressService.GetNewsArticlesAsync(TestSetup.Tokens.TeamworkToken).Result);
}
