public async Task Poll(CommandContext ctx, string time, params DiscordEmoji[] options)
{
try
{
if (int.TryParse(time, out var minutes))
{
var interactivity = ctx.Client.GetInteractivity();
var pollOptions = options.Select(xe => xe.ToString());
var duration = new TimeSpan(0, 0, minutes, 0, 0);
var output = new DiscordEmbedBuilder()
.WithTitle("Poll Time!")
.WithDescription(string.Join(" **VS.** ", pollOptions));
var message = await ctx.RespondAsync(embed : output.Build());
foreach (var t in options)
{
await message.CreateReactionAsync(t);
}
var pollResult = await interactivity.CollectReactionsAsync(message, duration);
var results = pollResult.Reactions.Where(xkvp => options.Contains(xkvp.Key)).Select(xkvp => $"{xkvp.Key} wins the poll with **{xkvp.Value}** votes");
await ctx.RespondAsync(string.Join("\n", results));
}
else
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: Invalid number of days, try **.poll 5** :open_mouth: :smile:");
}
}
catch
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: Unable to create the poll, please use stock Discord emojis as options!");
}
}
public async Task Dictionary(CommandContext ctx, [RemainingText] string query)
{
if (string.IsNullOrWhiteSpace(query))
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: A word or phrase is required!");
}
else
{
var data = await DefinitionService.GetDefinitionForTermAsync(query);
if (data.Results.Count == 0)
{
await BotServices.SendErrorEmbedAsync(ctx, ":mag: No results found!");
}
else
{
for (var index = 0; index < data.Results.Count; index++)
{
foreach (var value in data.Results[index].Senses)
{
if (value.Definition != null)
{
await ctx.TriggerTypingAsync();
var definition = value.Definition.ToString();
if (!(value.Definition is string))
{
definition = ((JArray)JToken.Parse(value.Definition.ToString())).First.ToString();
}
var output = new DiscordEmbedBuilder()
.WithTitle($"Dictionary definition for **{query}**")
.WithDescription(definition.Length < 500 ? definition : definition.Take(500) + "...")
.WithFooter("Type go for the next definition")
.WithColor(DiscordColor.Blurple);
if (value.Examples != null)
{
output.AddField("Example", value.Examples.First().text);
}
await ctx.RespondAsync(embed : output.Build());
var interactivity = await ctx.Client.GetInteractivity()
.WaitForMessageAsync(m => m.Channel.Id == ctx.Channel.Id && m.Content.ToLower() == "go", TimeSpan.FromSeconds(10));
if (interactivity != null)
{
continue;
}
index = data.Results.Count;
break;
}
}
}
}
}
}
public async Task Purge(CommandContext ctx, DiscordMember member, int limit)
{
if (limit <= 0 || limit > 100)
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: Invalid number of messages to delete, must be in range of 1-100!");
}
var messages = await ctx.Channel.GetMessagesAfterAsync(ctx.Message.Id, limit);
var delete = messages.Where(message => !string.IsNullOrWhiteSpace(member.ToString()) && message.Author.Id == member.Id).ToList();
await ctx.Channel.DeleteMessagesAsync(delete).ConfigureAwait(false);
await ctx.RespondAsync($"Purged **{delete.Count}** messages by {member.Username}#{member.Discriminator} (ID:{member.Id})");
}
public async Task Overwatch(CommandContext ctx, string battletag, [RemainingText] string query)
{
if (string.IsNullOrWhiteSpace(battletag))
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: Battletag is required! Try **.ow CriticalFlaw#11354** (case-sensitive)");
}
else
{
var overwatch = new OverwatchClient();
var player = await overwatch.GetPlayerAsync(battletag);
if (player == null)
{
await BotServices.SendErrorEmbedAsync(ctx, ":mag: Player not found! Remember, battletags are case-sensitive.");
}
else
{
await ctx.TriggerTypingAsync();
var output = new DiscordEmbedBuilder()
.WithTitle(player.Username)
.AddField("Level", player.PlayerLevel.ToString(), true)
.AddField("Competitive", player.CompetitiveRank.ToString(), true)
.AddField("Platform", player.Platform.ToString().ToUpper(), true)
.AddField("Achievements", player.Achievements.Count.ToString(), true)
.WithThumbnailUrl(player.ProfilePortraitUrl)
.WithUrl(player.ProfileUrl)
.WithColor(DiscordColor.Gold);
// Add Casual or Competitive stats if a query is present
switch (query.ToUpperInvariant())
{
case "CASUAL":
output.AddField("Healing Done", player.CasualStats.GetStatExact("All Heroes", "Assists", "Healing Done").Value.ToString(), true);
output.WithFooter("Casual stats shown are for All Heroes");
break;
case "COMP":
case "COMPETITIVE":
output.AddField("Healing Done", player.CompetitiveStats.GetStatExact("All Heroes", "Assists", "Healing Done").Value.ToString(), true);
output.WithFooter("Competitive stats shown are for All Heroes");
break;
default:
// Do nothing...
break;
}
await ctx.RespondAsync(embed : output.Build());
}
}
}
public async Task Shorten(CommandContext ctx, [RemainingText] string query)
{
if (!Uri.IsWellFormedUriString(query, UriKind.RelativeOrAbsolute)) // && (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps))
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: A valid URL link is required!");
}
else
{
await ctx.TriggerTypingAsync();
var shortenService = new ShortenService();
await ctx.RespondAsync(shortenService.shortenUrl(query));
}
}
public async Task CreateRole(CommandContext ctx, [RemainingText] string role)
{
if (string.IsNullOrWhiteSpace(role))
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: Role name cannot be blank!");
}
else
{
await ctx.TriggerTypingAsync();
await ctx.Guild.CreateRoleAsync(role);
await ctx.RespondAsync($"Role **{role}** has been **created**");
}
}
public async Task DeleteRole(CommandContext ctx, [RemainingText] DiscordRole role)
{
if (role == null)
{
await BotServices.SendErrorEmbedAsync(ctx, ":mag: Role not found in this server!");
}
else
{
await ctx.TriggerTypingAsync();
await role.DeleteAsync();
await ctx.RespondAsync($"Role **{role.Name}** has been **removed**");
}
}
public async Task SetChannelName(CommandContext ctx, [RemainingText] string name)
{
if (string.IsNullOrWhiteSpace(name))
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: Channel name cannot be blank!");
}
else
{
await ctx.TriggerTypingAsync();
await ctx.Channel.ModifyAsync(chn => chn.Name = name.Trim().Replace(" ", "-"));
await ctx.RespondAsync($"Channel name has been changed to **{name.Trim().Replace(" ", "-")}**");
}
}
public async Task SetServerName(CommandContext ctx, [RemainingText] string name)
{
if (string.IsNullOrWhiteSpace(name))
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: Server name cannot be blank!");
}
else
{
await ctx.TriggerTypingAsync();
await ctx.Guild.ModifyAsync(srv => srv.Name = $"{name}");
await ctx.RespondAsync($"Server name has been changed to **{name}**");
}
}
public async Task PruneUsers(CommandContext ctx, string day)
{
if (int.TryParse(day, out var days))
{
await ctx.TriggerTypingAsync();
await ctx.RespondAsync($"**{ctx.Guild.GetPruneCountAsync(days).Result}** server members have been pruned.");
await ctx.Guild.PruneAsync(days);
}
else
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: Invalid number of days, try **.prune 30**");
}
}
public async Task RemoveUserRoles(CommandContext ctx, DiscordMember member)
{
if (member.Roles.Max(r => r.Position) >= ctx.Member.Roles.Max(r => r.Position))
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: You are not authorised to remove roles from this user!");
}
else
{
await ctx.TriggerTypingAsync();
await member.ReplaceRolesAsync(Enumerable.Empty <DiscordRole>()).ConfigureAwait(false);
await ctx.RespondAsync($"Removed all roles from {member.DisplayName}");
}
}
public async Task CreateVoiceChannel(CommandContext ctx, [RemainingText] string channel)
{
if (string.IsNullOrWhiteSpace(channel))
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: Channel name cannot be blank!");
}
else
{
await ctx.TriggerTypingAsync();
await ctx.Guild.CreateChannelAsync(channel.Trim().Replace(" ", "-"), ChannelType.Voice, ctx.Channel.Parent);
await ctx.RespondAsync($"Voice Channel **#{channel.Trim().Replace(" ", "-")}** has been **created**");
}
}
public async Task YouTubeChannel(CommandContext ctx, [RemainingText] string query)
{
if (string.IsNullOrWhiteSpace(query))
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: Channel search query is required!");
}
else
{
await ctx.TriggerTypingAsync();
var youTubeService = new YoutubeService();
var output = await youTubeService.GetEmbeddedResults(query, 5, "channel");
await ctx.RespondAsync($"Search results for {Formatter.Bold(query)}", embed : output);
}
}
public async Task SteamServerLink(CommandContext ctx, [RemainingText] string link)
{
await ctx.TriggerTypingAsync();
var regexes = new Regex(@"connect\s*(?'ip'\S+)\s*;\s*password\s*(?'pw'\S+);?", RegexOptions.Compiled);
var match = regexes.Match(link);
if (match.Success)
{
await ctx.RespondAsync(string.Format($"steam://connect/{match.Groups["ip"].Value}/{match.Groups["pw"].Value}"));
}
else
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: Invalid connection info, follow the format: **connect 123.345.56.789:00000; password hello**");
}
}
public async Task Deafen(CommandContext ctx, DiscordMember member, [RemainingText] string reason = null)
{
if (member.IsDeafened)
{
await BotServices.SendErrorEmbedAsync(ctx, $"{member.DisplayName}#{member.Discriminator} is already **deafened**!");
}
else
{
await ctx.TriggerTypingAsync();
var rstr = string.IsNullOrWhiteSpace(reason) ? "" : $": {reason}";
await member.SetDeafAsync(true, rstr);
await ctx.RespondAsync($"**Deafened** user {member.DisplayName}#{member.Discriminator} (ID:{member.Id})\n**Reason:** {rstr}\n**Deafened by: **{ctx.Member.DisplayName}");
}
}
public async Task OMDB(CommandContext ctx, [RemainingText] string query)
{
if (string.IsNullOrWhiteSpace(query))
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: A search query is required!");
}
else
{
var service = new BotServices();
var client = new OMDbClient(service.GetAPIToken("omdb"), true);
var movie = await client.GetItemByTitle(query.Replace(" ", "+"));
if (movie.Response == "False")
{
await BotServices.SendErrorEmbedAsync(ctx, ":mag: No results found!");
}
else
{
await ctx.TriggerTypingAsync();
var output = new DiscordEmbedBuilder()
.WithTitle(movie.Title)
.WithDescription(movie.Plot.Length < 500 ? movie.Plot : movie.Plot.Take(500) + "...")
.AddField("Released", movie.Released, true)
.AddField("Runtime", movie.Runtime, true)
.AddField("Genre", movie.Genre, true)
.AddField("Country", movie.Country, true)
.AddField("Box Office", movie.BoxOffice, true)
.AddField("Production", movie.Production, true)
.AddField("IMDB Rating", movie.imdbRating, true)
.AddField("Metacritic", movie.Metascore, true)
.AddField("Rotten Tomatoes", movie.tomatoRating, true)
.AddField("Director", movie.Director, true)
.AddField("Actors", movie.Actors, true)
.WithColor(DiscordColor.Goldenrod);
if (movie.Poster != "N/A")
{
output.WithImageUrl(movie.Poster);
}
if (movie.tomatoURL != "N/A")
{
output.WithUrl(movie.tomatoURL);
}
await ctx.RespondAsync(embed : output.Build());
}
}
}
public async Task Mute(CommandContext ctx, DiscordMember member, [RemainingText] string reason = null)
{
if (member.IsMuted)
{
await BotServices.SendErrorEmbedAsync(ctx, $"{member.DisplayName}#{member.Discriminator} is already **muted**!");
}
else
{
await ctx.TriggerTypingAsync();
var ustr = $"{ctx.User.Username}#{ctx.User.Discriminator} ({ctx.User.Id})";
var rstr = string.IsNullOrWhiteSpace(reason) ? "" : $": {reason}";
await member.SetMuteAsync(true, $"{ustr}: {rstr}");
await ctx.RespondAsync($"**Muted** user {member.DisplayName}#{member.Discriminator} (ID:{member.Id})\n**Reason:** {rstr}");
}
}
public async Task Kick(CommandContext ctx, DiscordMember member, [RemainingText] string reason = null)
{
if (ctx.Member.Id == member.Id)
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: You cannot kick yourself!");
}
else
{
await ctx.TriggerTypingAsync();
var ustr = $"{ctx.User.Username}#{ctx.User.Discriminator} ({ctx.User.Id})";
var rstr = string.IsNullOrWhiteSpace(reason) ? "" : $": {reason}";
await member.RemoveAsync($"{ustr}: {rstr}");
await ctx.RespondAsync($"**Kicked** user {member.DisplayName}#{member.Discriminator} (ID:{member.Id})\n**Reason:** {rstr}");
}
}
public async Task EightBall(CommandContext ctx, [RemainingText] string question)
{
if (string.IsNullOrWhiteSpace(question))
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: You have to ask a question!");
}
else
{
await ctx.TriggerTypingAsync();
var rnd = new Random();
var output = new DiscordEmbedBuilder()
.WithTitle($":8ball: {EightBallAnswers.list[rnd.Next(0, EightBallAnswers.list.Count)]}")
.WithColor(DiscordColor.Black);
await ctx.RespondAsync(embed : output.Build());
}
}
public async Task UrbanDictionary(CommandContext ctx, [RemainingText] string query)
{
if (string.IsNullOrWhiteSpace(query))
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: A word or phrase is required!");
}
else
{
var data = await DictionaryService.GetDictionaryForTermAsync(query);
if (data.result_type == "no_results")
{
await BotServices.SendErrorEmbedAsync(ctx, ":mag: No results found!");
}
else
{
foreach (var value in data.list)
{
await ctx.TriggerTypingAsync();
var output = new DiscordEmbedBuilder()
.WithTitle($"Urban Dictionary definition for **{query}** by {value.author}")
.WithDescription(value.definition.Length < 500 ? value.definition : value.definition.Take(500) + "...")
.WithUrl(value.permalink)
.WithFooter("Type next for the next definition")
.WithColor(DiscordColor.Blurple);
if (!string.IsNullOrWhiteSpace(value.example))
{
output.AddField("Example", value.example);
}
output.AddField(":thumbsup:", value.thumbs_up.ToString(), true);
output.AddField(":thumbsdown:", value.thumbs_down.ToString(), true);
await ctx.RespondAsync(embed : output.Build());
var interactivity = await ctx.Client.GetInteractivity()
.WaitForMessageAsync(m => m.Channel.Id == ctx.Channel.Id && m.Content.ToLower() == "next", TimeSpan.FromSeconds(10));
if (interactivity == null)
{
break;
}
}
}
}
}
public async Task GetTime(CommandContext ctx, [RemainingText] string location)
{
if (string.IsNullOrWhiteSpace(location))
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: A valid location is required! Try **.time Ottawa, CA**");
}
else
{
try
{
await ctx.TriggerTypingAsync();
var http = new HttpClient();
http.DefaultRequestHeaders.Clear();
var service = new BotServices();
var token = service.GetAPIToken("google");
var locationResource = await http.GetStringAsync($"https://maps.googleapis.com/maps/api/geocode/json?address={location.Replace(" ", "")}&key={token}");
var locationObject = JsonConvert.DeserializeObject <TimeService>(locationResource);
if (locationObject.status != "OK")
{
await BotServices.SendErrorEmbedAsync(ctx, ":mag: Location not found!");
}
else
{
var currentSeconds = (int)DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds;
var url = $"https://maps.googleapis.com/maps/api/timezone/json?location={locationObject.results[0].geometry.location.lat},{locationObject.results[0].geometry.location.lng}×tamp={currentSeconds}&key={token}";
var timeResource = await http.GetStringAsync(url);
var timeObject = JsonConvert.DeserializeObject <TimeService.TimeZoneResult>(timeResource);
var time = DateTime.UtcNow.AddSeconds(timeObject.dstOffset + timeObject.rawOffset);
var output = new DiscordEmbedBuilder()
.WithTitle($"Time in {locationObject.results[0].formatted_address}")
.WithDescription($":clock1: **{time.ToShortTimeString()}** {timeObject.timeZoneName}")
.WithColor(DiscordColor.Cyan);
await ctx.RespondAsync(embed : output.Build());
}
}
catch
{
await BotServices.SendErrorEmbedAsync(ctx, ":mag: Unable to find time data for this location!");
}
}
}
public async Task RemoveVoiceChannel(CommandContext ctx, [RemainingText] DiscordChannel channel)
{
if (channel == null)
{
await BotServices.SendErrorEmbedAsync(ctx, ":mag: Channel not found in this server!");
}
else if (channel.Type != ChannelType.Voice)
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: This is not a voice channel, use **.deletetext** instead!");
}
else
{
await ctx.TriggerTypingAsync();
await channel.DeleteAsync();
await ctx.RespondAsync($"Voice Channel **{channel.Name}** has been **removed**");
}
}
public async Task Twitch(CommandContext ctx, [RemainingText] string stream)
{
if (string.IsNullOrWhiteSpace(stream))
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: An existing Twitch channel name is required!");
}
else
{
try
{
await ctx.TriggerTypingAsync();
var http = new HttpClient();
var service = new BotServices();
var twitchUrl = $"https://api.twitch.tv/kraken/streams/{stream.ToLower()}?client_id={service.GetAPIToken("twitch")}";
var response = await http.GetStringAsync(twitchUrl).ConfigureAwait(false);
var twitch = JsonConvert.DeserializeObject <TwitchService>(response);
twitch.Url = twitchUrl;
if (!twitch.IsLive)
{
await BotServices.SendErrorEmbedAsync(ctx, "Channel is **Offline** (or doesn't exist) :pensive:");
}
else
{
var output = new DiscordEmbedBuilder()
.WithTitle($"{twitch.Stream.Channel.display_name} is live streaming on Twitch!")
.AddField("Now Playing", twitch.Game)
.AddField("Stream Title", twitch.Title)
.AddField("Followers", twitch.Followers.ToString(), true)
.AddField("Viewers", twitch.Viewers.ToString(), true)
.WithThumbnailUrl(twitch.Icon)
.WithUrl(twitch.Url)
.WithColor(DiscordColor.Purple);
await ctx.RespondAsync(embed : output.Build());
}
}
catch
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: Unable to determine channel status, please do not include special characters in your input!");
}
}
}
public async Task Math(CommandContext ctx, double num1, string operation, double num2)
{
try
{
double result;
switch (operation)
{
case "+":
result = num1 + num2;
break;
case "-":
result = num1 - num2;
break;
case "*":
result = num1 * num2;
break;
case "/":
result = num1 / num2;
break;
case "%":
result = num1 % num2;
break;
default:
result = num1 + num2;
break;
}
var output = new DiscordEmbedBuilder()
.WithTitle($":1234: The result is {result:#,##0.00}")
.WithColor(DiscordColor.CornflowerBlue);
await ctx.RespondAsync(embed : output.Build());
}
catch
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: Error calculating math equation, make sure your values are integers and the operation is valid!");
}
}
public async Task Weather(CommandContext ctx, [RemainingText] string location)
{
if (string.IsNullOrWhiteSpace(location))
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: A valid location is required! Try **.weather Ottawa, CA**");
}
else
{
try
{
await ctx.TriggerTypingAsync();
var http = new HttpClient();
http.DefaultRequestHeaders.Clear();
var response = await http.GetStringAsync($"http://api.openweathermap.org/data/2.5/weather?q={location}&appid=42cd627dd60debf25a5739e50a217d74&units=metric");
var weather = JsonConvert.DeserializeObject <WeatherService.WeatherData>(response);
if (weather.cod == 404)
{
await BotServices.SendErrorEmbedAsync(ctx, ":mag: Location not found!");
}
else
{
Func <double, double> format = WeatherService.CelsiusToFahrenheit;
var output = new DiscordEmbedBuilder()
.AddField("Location", $"[{weather.name + ", " + weather.sys.country}](https://openweathermap.org/city/{weather.id})", true)
.AddField("Temperature", $"{weather.main.temp:F1}°C / {format(weather.main.temp):F1}°F", true)
.AddField("Conditions", string.Join(", ", weather.weather.Select(w => w.main)), true)
.AddField("Humidity", $"{weather.main.humidity}%", true)
.AddField("Wind Speed", $"{weather.wind.speed}m/s", true)
.AddField("Temperature (Min/Max)", $"{weather.main.tempMin:F1}°C - {weather.main.tempMax:F1}°C\n{format(weather.main.tempMin):F1}°F - {format(weather.main.tempMax):F1}°F", true)
.WithColor(DiscordColor.Cyan);
await ctx.RespondAsync(embed : output.Build());
}
}
catch
{
await BotServices.SendErrorEmbedAsync(ctx, ":mag: Unable to find weather data for this location!");
}
}
}
public async Task Clean(CommandContext ctx, int limit, [RemainingText] DiscordChannel channel)
{
if (limit <= 0 || limit > 100)
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: Invalid number of messages to delete, must be in range of 1-100!");
}
else
{
await ctx.TriggerTypingAsync();
if (channel == null)
{
channel = ctx.Channel;
}
var messages = await ctx.Channel.GetMessagesAsync(limit).ConfigureAwait(false);
await ctx.Channel.DeleteMessagesAsync(messages).ConfigureAwait(false);
await ctx.RespondAsync($"**{messages.Count}** message(s) have been removed from #{ctx.Channel.Name}");
}
}
public async Task TF2Wiki(CommandContext ctx, [RemainingText] string query)
{
if (string.IsNullOrWhiteSpace(query))
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: TF2Wiki search query is a required!");
}
else
{
await ctx.TriggerTypingAsync();
var http = new HttpClient();
var textInfo = new CultureInfo("en-US", false).TextInfo;
string search = null;
foreach (var term in query.Split(' '))
{
if (term.Length <= 2)
{
search += $"{term} ";
}
else
{
search += $"{textInfo.ToTitleCase(term)} ";
}
}
if (search != null)
{
var result = await http.GetStringAsync($"https://wiki.teamfortress.com/w/api.php?action=query&format=json&prop=info&redirects=1&formatversion=2&inprop=url&titles={Uri.EscapeDataString(search.Replace(' ', '_').Trim())}");
var data = JsonConvert.DeserializeObject <WikipediaService>(result);
if (data.Query.Pages[0].Missing)
{
await BotServices.SendErrorEmbedAsync(ctx, ":mag: TF2Wiki page not found!");
}
else
{
await ctx.Channel.SendMessageAsync(data.Query.Pages[0].FullUrl, embed : null).ConfigureAwait(false);
}
}
}
}
public async Task SetServerAvatar(CommandContext ctx, string query)
{
if (!Uri.TryCreate(query, UriKind.Absolute, out var uriResult) && (!query.EndsWith(".img") || !query.EndsWith(".png") || !query.EndsWith(".jpg")))
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: An image URL ending with .img, .png or .jpg is required!");
}
else
{
await ctx.TriggerTypingAsync();
using (var client = new WebClient())
{
var stream = new MemoryStream();
var data = client.DownloadData(query);
stream.Write(data, 0, data.Length);
stream.Position = 0;
await ctx.Guild.ModifyAsync(chn => chn.Icon = stream);
await ctx.RespondAsync($"{ctx.Guild.Name} server avatar has been updated!");
}
}
}
public async Task ColorRole(CommandContext ctx, params string[] colors)
{
try
{
if (colors.Length != 2 && colors.Length != 4)
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: Invalid parameters, try **.colorrole admin [0-255] [0-255] [0-255]**");
}
else
{
await ctx.TriggerTypingAsync();
var roleName = colors[0].ToLowerInvariant();
var role = ctx.Guild.Roles.FirstOrDefault(r => r.Name.ToLowerInvariant() == roleName);
if (role == null)
{
await BotServices.SendErrorEmbedAsync(ctx, ":mag: Role not found in this server!");
}
else
{
var rgb = colors.Length == 4;
var arg = colors[1].Replace("#", "");
var color = new DiscordColor(
Convert.ToByte(rgb ? int.Parse(arg) : Convert.ToInt32(arg.Substring(0, 2), 16)),
Convert.ToByte(rgb ? int.Parse(colors[2]) : Convert.ToInt32(arg.Substring(2, 2), 16)),
Convert.ToByte(rgb ? int.Parse(colors[3]) : Convert.ToInt32(arg.Substring(4, 2), 16)));
await role.UpdateAsync(color : color).ConfigureAwait(false);
await ctx.RespondAsync($"Color of the role **{roleName}** has been changed to **{color}**");
}
}
}
catch
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: Unable to change role color, try **.colorrole admin [0-255] [0-255] [0-255]**");
}
}
public async Task Pokemon(CommandContext ctx, [RemainingText] string query)
{
if (string.IsNullOrWhiteSpace(query))
{
await BotServices.SendErrorEmbedAsync(ctx, ":warning: Pokemon name is required! Try **.poke charizard**");
}
else
{
var pokemon = await PokemonService.GetPokemonDataAsync(query);
if (pokemon.cards.Count == 0)
{
await BotServices.SendErrorEmbedAsync(ctx, ":mag: Pokemon not found!");
}
else
{
await ctx.TriggerTypingAsync();
var rnd = new Random();
var cards = Card.Find <Pokemon>(pokemon.cards[rnd.Next(0, pokemon.cards.Count)].id);
var output = new DiscordEmbedBuilder()
.WithTitle($"{cards.Card.Name} (ID: {cards.Card.NationalPokedexNumber})")
.AddField("Health Points", cards.Card.Hp, true)
.AddField("Artist", cards.Card.Artist, true)
.AddField("Rarity", cards.Card.Rarity, true)
.AddField("Series", cards.Card.Series, true)
.WithImageUrl(cards.Card.ImageUrl)
.WithColor(DiscordColor.Lilac)
.WithFooter($"Card ID: {cards.Card.Id}");
if (cards.Card.ImageUrlHiRes != null)
{
output.WithImageUrl(cards.Card.ImageUrlHiRes); // Replace with high resolution image if available
}
await ctx.RespondAsync(embed : output.Build());
}
}
}
