示例#1
0
 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);
 }
示例#2
0
        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 GetMapStats()
 {
     Assert.IsNotNull(TeamFortressService.GetMapStatsAsync("pl_upward").Result.Name);
     Assert.IsNotNull(TeamFortressService.GetMapStatsAsync("upward").Result.Name);
     Assert.IsNull(TeamFortressService.GetMapStatsAsync("onpward").Result.Name);
 }
示例#4
0
        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);
        }