//public static async Task<DiscordMessage> GetFirstMessage(this DiscordClient client, string lobbyName)
//{
// var lobbyChannel = client.GetChannelByName(lobbyName);
// if (lobbyChannel == null)
// {
// Utils.LogError(new Exception($"Unrecognized lobby name '{lobbyName}'."));
// return null;
// }
// var messages = await lobbyChannel.GetMessagesAsync();
// if (messages != null)
// {
// return messages[messages.Count - 1];
// }
// return null;
//}
#region Old Raid Lobby System
//public static async Task<DiscordMessage> UpdateLobbyStatus(this DiscordClient client, RaidLobby lobby)
//{
// if (lobby == null)
// {
// Utils.LogError(new Exception($"Failed to get lobby from database."));
// return null;
// }
// var lobbyChannel = await client.GetChannel(lobby.ChannelId);
// if (lobbyChannel == null)
// {
// Utils.LogError(new Exception($"Failed to get raid lobby channel from {lobby.LobbyName} ({lobby.ChannelId})."));
// return null;
// }
// var pinnedMessage = await lobbyChannel.GetMessageAsync(lobby.PinnedRaidMessageId);
// if (pinnedMessage == null)
// {
// Utils.LogError(new Exception($"Failed to get pinned raid lobby message from message id {lobby.PinnedRaidMessageId}."));
// return null;
// }
// return await pinnedMessage.ModifyAsync(new Optional<string>(await CreateLobbyStatus(client, lobby)));
//}
//public static async Task<DiscordMessage> SendLobbyStatus(this DiscordClient client, RaidLobby lobby, DiscordEmbed embed, bool pin)
//{
// if (lobby == null)
// {
// Utils.LogError(new Exception($"Failed to get lobby from database."));
// return null;
// }
// var lobbyChannel = await client.GetChannel(lobby.ChannelId);
// if (lobbyChannel == null)
// {
// Utils.LogError(new Exception($"Failed to get raid lobby channel from {lobby.LobbyName} ({lobby.ChannelId})."));
// return null;
// }
// var message = await lobbyChannel.SendMessageAsync(await CreateLobbyStatus(client, lobby), false, embed);
// if (pin) await message.PinAsync();
// lobby.PinnedRaidMessageId = message.Id;
// return message;
//}
//public static async Task<string> RaidLobbyUserStatus(this DiscordClient client, RaidLobby lobby)
//{
// var lobbyUserStatus = "**Raid Lobby User Status:**\r\n";
// foreach (var lobbyUser in lobby.UserCheckInList)
// {
// var user = await client.GetUser(lobbyUser.UserId);
// if (user == null)
// {
// Utils.LogError(new Exception($"Failed to find user {lobbyUser.UserId}"));
// return string.Empty;
// }
// var people = lobbyUser.UserCount;
// if (lobbyUser.IsCheckedIn && !lobbyUser.IsOnTheWay)
// {
// lobbyUserStatus += $"{user.Mention} **checked-in** at {lobbyUser.CheckInTime.ToLongTimeString()} and is ready to start.\r\n";
// }
// else
// {
// lobbyUserStatus += $"{user.Mention} was **on the way** at **{lobbyUser.OnTheWayTime.ToLongTimeString()}** with {lobbyUser.UserCount} participants and an ETA of {lobbyUser.ETA}.\r\n";
// }
// lobbyUserStatus +=
// $"{lobby.NumUsersOnTheWay} users on their way.\r\n" +
// $"{lobby.NumUsersCheckedIn} users already checked in and ready.\r\n" +
// $"**{lobby.NumUsersCheckedIn}/{lobby.NumUsersCheckedIn + lobby.NumUsersOnTheWay}** Users Ready!\r\n";
// }
// return lobbyUserStatus;
//}
//private static async Task<string> CreateLobbyStatus(DiscordClient client, RaidLobby lobby)
//{
// return $"**{lobby.LobbyName} RAID LOBBY** ({DateTime.Now.ToLongDateString()})\r\n" +
// $"**{Convert.ToUInt32(lobby.MinutesLeft)} Minutes Left!**\r\n" + //TODO: Fix minutes left.
// $"Raid Boss: **{lobby.PokemonName}**\r\n" +
// $"Start Time: {lobby.StartTime.ToLongTimeString()}\r\n" +
// $"Expire Time: {lobby.ExpireTime.ToLongTimeString()}\r\n" +
// $"Gym Name: {lobby.GymName}\r\n" +
// $"Address: {lobby.Address}\r\n\r\n" +
// await RaidLobbyUserStatus(client, lobby);
//}
#endregion
#endregion
#region Raid Lobby Reaction Extensions
public static async Task SetDefaultRaidReactions(this DiscordClient client, DiscordMessage message, bool isLobby, bool deleteExisting = true)
{
if (client == null)
{
return;
}
if (deleteExisting)
{
await message.DeleteAllReactionsAsync();
await Utils.Wait(10);
}
await message.CreateReactionAsync(DiscordEmoji.FromName(client, ":arrow_right:"));
await message.CreateReactionAsync(DiscordEmoji.FromName(client, ":white_check_mark:"));
if (isLobby)
{
await message.CreateReactionAsync(DiscordEmoji.FromName(client, ":x:"));
await message.CreateReactionAsync(DiscordEmoji.FromName(client, ":arrows_counterclockwise:"));
}
}
// Initates multiplayer game
public async Task BeginMultiplayerGame()
{
Multiplayer = true;
EmbedDefaults.SetEmbedDefaultsMP(p1, p2);
ActivePlayer = p1.Name;
// Creates and sends the embed that is used as the gameboard
DiscordEmbedBuilder gameBoard = CreatePlayField(grid.GameGrid);
DiscordMessage embedMessage = await ctx.Channel.SendMessageAsync(embed : gameBoard).ConfigureAwait(false);
await AddReactions(embedMessage);
// Loops the game until the game is over.
while (GameActive)
{
await MakeMove(embedMessage);
Turn++;
}
SetWinnerStatus(p1, p2);
RegisterInDatabase(p1, p2);
await embedMessage.ModifyAsync(embed : new Optional <DiscordEmbed>(CreatePlayField(grid.GameGrid))).ConfigureAwait(false);
await embedMessage.DeleteAllReactionsAsync();
}
public static async Task SetAccountsReactions(this DiscordClient client, DiscordMessage message, bool deleteExisting = true)
{
if (client == null)
{
return;
}
if (deleteExisting)
{
await message.DeleteAllReactionsAsync();
}
await message.CreateReactionAsync(DiscordEmoji.FromName(client, ":one:"));
await message.CreateReactionAsync(DiscordEmoji.FromName(client, ":two:"));
await message.CreateReactionAsync(DiscordEmoji.FromName(client, ":three:"));
await message.CreateReactionAsync(DiscordEmoji.FromName(client, ":four:"));
//await message.CreateReactionAsync(DiscordEmoji.FromName(client, ":five:"));
//await message.CreateReactionAsync(DiscordEmoji.FromName(client, ":six:"));
//await message.CreateReactionAsync(DiscordEmoji.FromName(client, ":seven:"));
//await message.CreateReactionAsync(DiscordEmoji.FromName(client, ":eight:"));
//await message.CreateReactionAsync(DiscordEmoji.FromName(client, ":nine:"));
//await message.CreateReactionAsync(DiscordEmoji.FromName(client, ":ten:"));
}
public async Task Sendreactiongear(CommandContext ctx, DiscordMessage embedMessage, bool userSelf)
{
if (userSelf == true)
{
DiscordEmoji gearEmoji = DiscordEmoji.FromName(ctx.Client, ":gear:");
await embedMessage.CreateReactionAsync(gearEmoji).ConfigureAwait(false);
var interactivity = ctx.Client.GetInteractivity();
try
{
var ReactionResult = await interactivity.WaitForReactionAsync(
x => x.Message == embedMessage &&
x.User == ctx.User &&
(x.Emoji == gearEmoji)).ConfigureAwait(false);
if (ReactionResult.Result.Emoji == gearEmoji)
{
await embedMessage.DeleteAsync(null);
await SetId(ctx, ctx.Member.Id, userSelf);
return;
}
}
catch
{
await embedMessage.DeleteAllReactionsAsync(null);
}
}
}
private async Task UpdateReactions()
{
if (message != null)
{
try {
await message.DeleteAllReactionsAsync("Clearing all reactions for page update");
} catch (UnauthorizedException) {
remindMe.BotMethods.Log(this, new LogEventArgs {
Message = $"ReminderList tried clearing reactions, but couldn't because it doesn't have permission. An alternative method will be used but only this bot's reactions will be removed.",
Type = LogType.Warning
});
foreach (var reaction in message.Reactions)
{
if (reaction.IsMe)
{
await message.DeleteOwnReactionAsync(reaction.Emoji);
}
}
}
if (CanGoLeftPage)
{
await message.CreateReactionAsync(LeftArrowEmoji);
}
for (int i = 0; i < NumberOfRemindersOnPage; ++i)
{
await message.CreateReactionAsync(DigitEmojis[i]);
}
if (CanGoRightPage)
{
await message.CreateReactionAsync(RightArrowEmoji);
}
}
}
public async Task AddGuildEvent(CommandContext context)
{
DiscordMessage msg = await context.RespondAsync($":wave: Hi, {context.User.Mention}! You wanted to create a new event?");
await msg.CreateReactionAsync(DiscordEmoji.FromName(context.Client, ":regional_indicator_y:"));
await msg.CreateReactionAsync(DiscordEmoji.FromName(context.Client, ":regional_indicator_n:"));
InteractivityExtension interactivity = context.Client.GetInteractivity();
InteractivityResult <MessageReactionAddEventArgs> interactivityResult = await interactivity.WaitForReactionAsync(msg, context.User);
if (interactivityResult.TimedOut ||
!interactivityResult.Result.Emoji.Equals(DiscordEmoji.FromName(context.Client, ":regional_indicator_y:")))
{
DiscordMessage snark = await context.RespondAsync("Well, thanks for wasting my time. Have a good day.");
await Task.Delay(5000);
await context.Channel.DeleteMessagesAsync(new List <DiscordMessage> {
msg, snark, context.Message
});
return;
}
await context.Message.DeleteAsync();
await msg.DeleteAllReactionsAsync();
await this.AddGuildEventInteractive(context, interactivity, msg);
}
public static async Task <Reaction> AddAndWaitForYesNoReaction(this InteractivityExtension interactivity, DiscordMessage msg, DiscordUser user)
{
DiscordClient client = interactivity.Client;
await msg.CreateReactionAsync(DiscordEmoji.FromName(client, ":regional_indicator_y:"));
await msg.CreateReactionAsync(DiscordEmoji.FromName(client, ":regional_indicator_n:"));
InteractivityResult <MessageReactionAddEventArgs> interactivityResult = await interactivity.WaitForReactionAsync(msg, user);
if (interactivityResult.TimedOut || interactivityResult.Result.Emoji.Equals(DiscordEmoji.FromName(client, ":regional_indicator_n:")))
{
DiscordMessage snark = await interactivityResult.Result.Channel.SendMessageAsync($"{user.Mention}, well then why did you get my attention! Thanks for wasting my time. Let me clean up now. :triumph:");
await Task.Delay(5000);
await interactivityResult.Result.Channel.DeleteMessagesAsync(new List <DiscordMessage> {
msg, snark
});
return(interactivityResult.TimedOut ? Reaction.None : Reaction.No);
}
await msg.DeleteAllReactionsAsync();
return(Reaction.Yes);
}
public async Task <bool> Confirm(DiscordMessage msg, CommandContext ctx)
{
// first retrieve the interactivity module from the client
var interactivity = ctx.Client.GetInteractivity();
// specify the emoji
DiscordEmoji[] EmojiOptions =
{
DiscordEmoji.FromName(ctx.Client, ":white_check_mark:"),
DiscordEmoji.FromName(ctx.Client, ":x:")
};
foreach (DiscordEmoji e in EmojiOptions)
{
msg.CreateReactionAsync(e);
Thread.Sleep(350);
}
// wait for a reaction
var em = await interactivity.WaitForReactionAsync(xe => EmojiOptions.Contains(xe.Emoji), ctx.User, TimeSpan.FromSeconds(15));
if (!em.TimedOut)
{
return(em.Result.Emoji == EmojiOptions[0]);
}
else
{
await msg.DeleteAllReactionsAsync();
return(false);
}
}
public async Task Entrar(CommandContext ctx, string cenario)
{
switch (cenario)
{
case ("floresta"):
DiscordEmbedBuilder crianca = new DiscordEmbedBuilder()
.WithImageUrl("https://cdn.discordapp.com/attachments/836451973015928833/836451999263490078/D6PCcR2X4AYTpam.png")
.WithFooter("Clique em ⚔️ para atacar!");
DiscordMessage mensagem = await ctx.RespondAsync(crianca);
List <DiscordEmoji> aroji = new List <DiscordEmoji>();
aroji.Add(DiscordEmoji.FromName(ctx.Client, ":crossed_swords:"));
oi:
// Reage e espera a reação correta
DiscordEmoji emoji;
bool reacted;
try { (emoji, reacted) = await Embed.ReactAndAwait(mensagem, ctx.Member, aroji); }
// Termina em caso de timeout
catch { await Embed.End(mensagem); return; }
await mensagem.DeleteAllReactionsAsync();
goto oi;
break;
}
}
/// <summary>
/// Makes a poll and returns poll results.
/// </summary>
/// <param name="m">Message to create poll on.</param>
/// <param name="emojis">Emojis to use for this poll.</param>
/// <param name="behaviour">What to do when the poll ends.</param>
/// <param name="timeout">override timeout period.</param>
/// <returns></returns>
public async Task <ReadOnlyCollection <PollEmoji> > DoPollAsync(DiscordMessage m, IEnumerable <DiscordEmoji> emojis, PollBehaviour?behaviour = default, TimeSpan?timeout = null)
{
if (!Utilities.HasReactionIntents(this.Client.Configuration.Intents))
{
throw new InvalidOperationException("No reaction intents are enabled.");
}
if (emojis.Count() < 1)
{
throw new ArgumentException("You need to provide at least one emoji for a poll!");
}
foreach (var em in emojis)
{
await m.CreateReactionAsync(em).ConfigureAwait(false);
}
var res = await Poller.DoPollAsync(new PollRequest(m, timeout ?? this.Config.Timeout, emojis)).ConfigureAwait(false);
var pollbehaviour = behaviour ?? this.Config.PollBehaviour;
var thismember = await m.Channel.Guild.GetMemberAsync(this.Client.CurrentUser.Id).ConfigureAwait(false);
if (pollbehaviour == PollBehaviour.DeleteEmojis && m.Channel.PermissionsFor(thismember).HasPermission(Permissions.ManageMessages))
{
await m.DeleteAllReactionsAsync().ConfigureAwait(false);
}
return(new ReadOnlyCollection <PollEmoji>(res.ToList()));
}
public async Task SendTopGold(CommandContext ctx, DiscordMessage message, List <Profile> profiles, DiscordMember member)
{
await message.DeleteAllReactionsAsync();
List <ProfilesList> profilesList = new List <ProfilesList>();
foreach (Profile profile in profiles)
{
profilesList.Add(new ProfilesList
{
DiscordId = profile.DiscordId,
Gold = profile.Gold,
Level = profile.Level
});
}
var sortedList = profilesList.OrderByDescending(x => x.Gold).ToList();
StringBuilder sb = new StringBuilder();
int place = 1;
foreach (var user in sortedList)
{
try
{
if (user.Level >= 1 || user.Gold > 0)
{
sb.Append($"[{place}]\t> #{ctx.Guild.GetMemberAsync(user.DiscordId).Result.Username}\n\t\tGold: {user.Gold}\n\n");
place += 1;
}
}
catch { }
}
var profileEmbed = new DiscordEmbedBuilder
{
Timestamp = System.DateTime.Now,
Title = "Users with most gold:",
Description = $"```py\n{sb.ToString()}-------------------------------------------------------\n@This list only shows users who are level 1+ or have gold.\n@ To see more select an emoji below.\n```",
Color = DiscordColor.Orange
};
await message.ModifyAsync(content : " ", embed : profileEmbed.Build());
var emojiList = new List <DiscordEmoji>();
emojiList.Add(DiscordEmoji.FromName(ctx.Client, ":regional_indicator_x:"));
emojiList.Add(DiscordEmoji.FromName(ctx.Client, ":abc:"));
emojiList.Add(DiscordEmoji.FromName(ctx.Client, ":gotem:"));
emojiList.Add(DiscordEmoji.FromName(ctx.Client, ":beer:"));
foreach (var emoji in emojiList)
{
await message.CreateReactionAsync(emoji);
}
await AwaitTopReaction(ctx, message, profiles, member, emojiList).ConfigureAwait(false);
}
public async Task UnscheduleGuildEvent(CommandContext context)
{
using IBotAccessProvider provider = this.accessBuilder.Build();
InteractivityExtension interactivity = context.Client.GetInteractivity();
DiscordMessage msg = await context.RespondAsync(
$":wave: Hi, {context.User.Mention}! You want to unschedule an event for your guild?");
Reaction reaction = await interactivity.AddAndWaitForYesNoReaction(msg, context.User);
if (reaction != Reaction.Yes)
{
return;
}
await context.Message.DeleteAsync();
DateTimeZone memberTimeZone = this.timeZoneProvider[provider.GetUsersTimeZone(context.User.Id).TimeZoneId];
List <GuildBackgroundJob> guildEventJobs = provider.GetAllAssociatedGuildBackgroundJobs(context.Guild.Id)
.Where(x => x.GuildJobType == GuildJobType.SCHEDULED_EVENT)
.OrderBy(x => x.ScheduledTime)
.ToList();
DiscordEmbedBuilder removeEventEmbed = new DiscordEmbedBuilder()
.WithTitle("Select an event to unschedule by typing: <event number>")
.WithColor(context.Member.Color);
CustomResult <int> result = await context.WaitForMessageAndPaginateOnMsg(
GetScheduledEventsPages(guildEventJobs.Select(x => x.WithTimeZoneConvertedTo(memberTimeZone)), interactivity, removeEventEmbed),
PaginationMessageFunction.CreateWaitForMessageWithIntInRange(context.User, context.Channel, 1, guildEventJobs.Count + 1),
msg : msg);
if (result.TimedOut || result.Cancelled)
{
DiscordMessage snark = await context.RespondAsync("You never gave me a valid input. Thanks for wasting my time. :triumph:");
await Task.Delay(5000);
await context.Channel.DeleteMessagesAsync(new List <DiscordMessage> {
msg, snark
});
return;
}
GuildBackgroundJob job = guildEventJobs[result.Result - 1];
msg = await msg.ModifyAsync($"{context.User.Mention}, are you sure you want to unschedule this event?", embed : null);
reaction = await interactivity.AddAndWaitForYesNoReaction(msg, context.User);
BackgroundJob.Delete(job.HangfireJobId);
provider.DeleteGuildBackgroundJob(job);
await msg.DeleteAllReactionsAsync();
await msg.ModifyAsync("Ok, I've unscheduled that event!", embed : null);
}
public async Task Background(CommandContext ctx, int?page = null)
{
if (page == null || page <= 0)
{
page = 1;
}
var msgBuilder = new DiscordMessageBuilder()
.WithContent(CustomMethod.GetBackgroundList(ctx, (int)page))
.WithReply(ctx.Message.Id, true);
DiscordMessage TopMessage = await ctx.RespondAsync(msgBuilder);
DiscordEmoji left = DiscordEmoji.FromName(ctx.Client, ":arrow_left:");
DiscordEmoji right = DiscordEmoji.FromName(ctx.Client, ":arrow_right:");
await TopMessage.CreateReactionAsync(left);
await Task.Delay(300).ContinueWith(t => TopMessage.CreateReactionAsync(right));
bool end = false;
do
{
var result = TopMessage.WaitForReactionAsync(ctx.User, TimeSpan.FromSeconds(20));
if (result.Result.TimedOut)
{
end = result.Result.TimedOut;
}
else if (result.Result.Result.Emoji == left)
{
await TopMessage.DeleteReactionAsync(result.Result.Result.Emoji, ctx.User);
if (page > 1)
{
page--;
await TopMessage.ModifyAsync(CustomMethod.GetBackgroundList(ctx, (int)page));
}
}
else if (result.Result.Result.Emoji == right)
{
await TopMessage.DeleteReactionAsync(result.Result.Result.Emoji, ctx.User);
page++;
try
{
await TopMessage.ModifyAsync(CustomMethod.GetBackgroundList(ctx, (int)page));
}
catch (Exception)
{
page--;
}
}
} while (!end);
await TopMessage.DeleteAllReactionsAsync();
}
[Command("deletequeue"), RequirePermissions(Permissions.Administrator), Aliases(new[] { "dq" }), Description("Borra todos los elementos en la cola")] //,
public async Task deletequeue(CommandContext ctx)
{
DiscordMessage msg = await ctx.RespondAsync("Estas seguro que quieres eliminar toda la lista de recodes?");
bool confirmation = await Confirm(msg, ctx);
if (confirmation)
{
Encoder.Instance.EncodeQueue.Clear();
Encoder.Instance.SaveCurentQueueToFile();
Encoder.Instance.SendUpdateToChannel();
msg.ModifyAsync("Se han borrado todos los elementos");
msg.DeleteAllReactionsAsync();
}
else
{
msg.ModifyAsync("Operacion cancelada");
msg.DeleteAllReactionsAsync();
}
}
public async Task React(CommandContext ctx)
{
var emoji1 = DiscordEmoji.FromName(ctx.Client, ":one:");
var emoji2 = DiscordEmoji.FromName(ctx.Client, ":two:");
var embed = new DiscordEmbedBuilder()
{
Description = "1",
};
var embed2 = new DiscordEmbedBuilder()
{
Description = "2",
};
DiscordMessage Embed = await ctx.RespondAsync(embed : embed.Build());
await Embed.CreateReactionAsync(emoji1);
await Task.Delay(500);
await Embed.CreateReactionAsync(emoji2);
var interactivity = ctx.Client.GetInteractivity();
var result1 = await interactivity.WaitForReactionAsync(x => x.Emoji == emoji1, ctx.User, TimeSpan.FromSeconds(60));
var result2 = await interactivity.WaitForReactionAsync(x => x.Emoji == emoji2, ctx.User, TimeSpan.FromSeconds(60));
if (result1.Result != null)
{
await Embed.ModifyAsync(embed : embed.Build());
await Embed.DeleteAllReactionsAsync();
}
if (result2.Result != null)
{
await Embed.ModifyAsync(embed : embed2.Build());
await Embed.DeleteAllReactionsAsync();
}
}
public async Task deleteelement(CommandContext ctx, [Description("Numero de elemento que borrar")] int nqueue)
{
Encode e = Encoder.Instance.EncodeQueue.ToArray()[nqueue];
DiscordMessage msg = await ctx.RespondAsync($"Se borrara \"{e.Anime.GetInfo()}\"\nEstas de acuerdo?");
bool confirmation = await Confirm(msg, ctx);
if (confirmation)
{
Encoder.Instance.EncodeQueue.Remove(e);
Encoder.Instance.SaveCurentQueueToFile();
Encoder.Instance.SendUpdateToChannel();
msg.DeleteAllReactionsAsync();
msg.ModifyAsync($"Se ha borrado \"{e.Anime.GetInfo()}\" de la lista");
}
else
{
msg.DeleteAllReactionsAsync();
msg.ModifyAsync($"Operacion cancelada");
}
}
public async Task SendCooldownAlarm(CommandContext ctx, DiscordMessage msg, TimeSpan timeSpan)
{
try
{
await msg.CreateReactionAsync(DiscordEmoji.FromName(ctx.Client, ":alarm_clock:"));
var interactivity = ctx.Client.GetInteractivity();
var reaction = await interactivity.WaitForReactionAsync(
x => x.Message == msg &&
x.User.Id == ctx.Member.Id &&
x.Emoji == DiscordEmoji.FromName(ctx.Client, ":alarm_clock:"));
if (!reaction.TimedOut)
{
await msg.DeleteAllReactionsAsync();
DiscordDmChannel dmChannel = ctx.Guild.GetMemberAsync(ctx.Member.Id).Result.CreateDmChannelAsync().Result;
DiscordEmbedBuilder CooldownEmbed = new DiscordEmbedBuilder()
{
Title = $"Your timer has been set.",
Color = DiscordColor.Red
};
CooldownEmbed.WithFooter("Keep in mind this timer will only go off if the bot is not reset (which happens fairly often).");
await msg.ModifyAsync(embed : CooldownEmbed.Build());
System.Threading.Thread.Sleep(Convert.ToInt32(timeSpan.TotalMilliseconds));
await dmChannel.SendMessageAsync($"Your cooldown has ended, you can now rob to your hearts content.");
}
else
{
await msg.DeleteAllReactionsAsync();
}
}
catch { await msg.DeleteAllReactionsAsync().ConfigureAwait(false); }
}
public async Task UpdateEmissaryMessage(CommandContext ctx, DiscordMessage message)
{
if (!Bot.IsModerator(ctx.Member))
{
await ctx.RespondAsync($"{Bot.BotSettings.ErrorEmoji} У вас нет доступа к этой команде!");
return;
}
await ctx.Channel.DeleteMessageAsync(await ctx.Channel.GetMessageAsync(ctx.Channel.LastMessageId));
//Обновляем настроки бота
if (Bot.BotSettings.EmissaryMessageId != message.Id)
{
Bot.EditSettings("EmissaryMessageId", message.Id.ToString());
}
//Убираем все реакции с сообщения
await message.DeleteAllReactionsAsync();
//Добавляем реакции к сообщению
await message.CreateReactionAsync(DiscordEmoji.FromName(ctx.Client, ":moneybag:"));
await Task.Delay(400);
await message.CreateReactionAsync(DiscordEmoji.FromName(ctx.Client, ":pig:"));
await Task.Delay(400);
await message.CreateReactionAsync(DiscordEmoji.FromName(ctx.Client, ":skeleton:"));
await Task.Delay(400);
await message.CreateReactionAsync(DiscordEmoji.FromName(ctx.Client, ":gem:"));
await Task.Delay(400);
await message.CreateReactionAsync(DiscordEmoji.FromName(ctx.Client, ":skull_and_crossbones:"));
await Task.Delay(400);
await message.CreateReactionAsync(DiscordEmoji.FromName(ctx.Client, ":fish:"));
await Task.Delay(400);
await message.CreateReactionAsync(DiscordEmoji.FromName(ctx.Client, ":crossed_swords:"));
await Task.Delay(400);
await message.CreateReactionAsync(DiscordEmoji.FromName(ctx.Client, ":x:"));
}
public async Task TicTacToe(CommandContext ctx, DiscordMember member)
{
DiscordEmoji circle = DiscordEmoji.FromName(ctx.Client, ":o:");
DiscordEmoji cross = DiscordEmoji.FromName(ctx.Client, ":x:");
DiscordEmoji agree = DiscordEmoji.FromName(ctx.Client, ":+1:");
DiscordEmoji disagree = DiscordEmoji.FromName(ctx.Client, ":-1:");
DiscordMessage message = await ctx.Channel.SendMessageAsync(embed : Embeds.SendTttReactEmbed(member)).ConfigureAwait(false);
await message.CreateReactionAsync(agree).ConfigureAwait(false);
await message.CreateReactionAsync(disagree).ConfigureAwait(false);
InteractivityResult <MessageReactionAddEventArgs> reactionAsync = await message.WaitForReactionAsync(member, TimeSpan.FromSeconds(45));
if (reactionAsync.Result.Emoji.Name == agree.Name)
{
await message.DeleteAllReactionsAsync();
await message.ModifyAsync(
"Let's begin!\nType numbers 1-9 to make a move\n" +
circle + " Represents: " + member.Mention + " & This player begins\n" +
cross + " Represents: " + ctx.Member.Mention,
embed : null);
await TTT(ctx, member);
}
else if (reactionAsync.Result?.Emoji.Name == disagree.Name)
{
await message.DeleteAllReactionsAsync();
await message.ModifyAsync(embed : Embeds.Cancelled);
}
else if (reactionAsync.TimedOut)
{
await message.DeleteAllReactionsAsync();
await message.ModifyAsync(embed : Embeds.TimeOut);
}
}
public async Task DeleteReactionsAsync(CommandContext ctx,
[Description("Message.")] DiscordMessage message = null,
[RemainingText, Description("Reason.")] string reason = null)
{
message = message ?? (await ctx.Channel.GetMessagesBeforeAsync(ctx.Channel.LastMessageId, 1)).FirstOrDefault();
if (message == null)
{
throw new CommandFailedException("Cannot find the specified message.");
}
await message.DeleteAllReactionsAsync(ctx.BuildInvocationDetailsString(reason));
await this.InformAsync(ctx, important : false);
}
public async Task CodexMessage(CommandContext ctx, DiscordMessage message)
{
await ctx.Channel.DeleteMessageAsync(await ctx.Channel.GetMessageAsync(ctx.Channel.LastMessageId));
//Обновляем настроки бота
if (Bot.BotSettings.CodexMessageId != message.Id)
{
Bot.EditSettings("CodexMessageId", message.Id.ToString());
}
//Убираем все реакции с сообщения
await message.DeleteAllReactionsAsync();
//Добавляем реакции к сообщению
await message.CreateReactionAsync(DiscordEmoji.FromName(ctx.Client, ":white_check_mark:"));
}
public async Task SendBasicInfo(CommandContext ctx, DiscordMessage message, Profile profile, DiscordMember member)
{
await message.DeleteAllReactionsAsync();
var profileEmbed = new DiscordEmbedBuilder
{
Title = $"{member.DisplayName}'s Profile.",
Description = $"[Extra Stats](https://grafana.wiggims1.com/d/TclixHkMz/discord-member-stats?orgId=1&var-DiscordId={ member.Id }&var-GuildId={ ctx.Guild.Id}) Username and Password is 'guest'.",
Thumbnail = new DiscordEmbedBuilder.EmbedThumbnail {
Url = member.AvatarUrl
},
Color = member.Color,
Timestamp = System.DateTime.Now
};
profileEmbed.WithFooter("Please don't f**k around with shit on the Grafana website, Everyone shares the same account and id rather not take it down.");
profileEmbed.AddField("Level", $"{profile.Level.ToString()} - `{profile.Xp} xp`", true);
profileEmbed.AddField("Gold", ":moneybag: " + profile.Gold.ToString(), true);
profileEmbed.AddField("Gots", profile.Gots.ToString(), true);
profileEmbed.AddField("Boganness", profile.Boganometer.ToString() + " %", true);
if (profile.LeaveCount > 0)
{
profileEmbed.AddField("Leave count", profile.LeaveCount.ToString(), true);
}
await message.ModifyAsync(content : " ", embed : profileEmbed.Build());
var emojiList = new List <DiscordEmoji>();
emojiList.Add(DiscordEmoji.FromName(ctx.Client, ":abc:"));
emojiList.Add(DiscordEmoji.FromName(ctx.Client, ":joystick:"));
emojiList.Add(DiscordEmoji.FromName(ctx.Client, ":gear:"));
emojiList.Add(DiscordEmoji.FromName(ctx.Client, ":scroll:"));
if (member.Id == ctx.Member.Id)
{
emojiList.Add(DiscordEmoji.FromName(ctx.Client, ":shopping_cart:"));
}
foreach (var emoji in emojiList)
{
await message.CreateReactionAsync(emoji);
}
await AwaitReaction(ctx, message, profile, member, emojiList).ConfigureAwait(false);
}
public static async Task SetEtaReactions(this DiscordClient client, DiscordMessage message, bool deleteExisting = true)
{
if (client == null)
{
return;
}
if (deleteExisting)
{
await message.DeleteAllReactionsAsync();
}
await message.CreateReactionAsync(DiscordEmoji.FromName(client, ":five:"));
await message.CreateReactionAsync(DiscordEmoji.FromName(client, ":keycap_ten:"));
//TODO: Add more ETA reactions.
}
static public async Task <DiscordMessage> SendEmbed(DiscordMessage msg, DiscordEmbed embed, string content = "")
{
// Tenta editar a mensagem
DiscordMessage sentMsg;
try
{
await msg.DeleteAllReactionsAsync();
sentMsg = await msg.ModifyAsync(content, embed);
}
// Senão, manda uma mensagem nova
catch
{
sentMsg = await msg.Channel.SendMessageAsync(embed);
}
return(sentMsg);
}
public async Task DoCleanupAsync()
{
switch (_deletion)
{
case PaginationDeletion.DeleteEmojis:
await _message.DeleteAllReactionsAsync().ConfigureAwait(false);
break;
case PaginationDeletion.DeleteMessage:
await _message.DeleteAsync().ConfigureAwait(false);
break;
case PaginationDeletion.KeepEmojis:
break;
}
}
// ########### Profile Tasks ##############
public async Task AwaitReaction(CommandContext ctx, DiscordMessage message, Profile profile, DiscordMember member, List <DiscordEmoji> emojis)
{
try
{
var interactivity = ctx.Client.GetInteractivity();
foreach (var emoji in emojis)
{
await message.CreateReactionAsync(emoji);
}
var ReactionResult = await interactivity.WaitForReactionAsync(
x => x.Message == message &&
x.User == ctx.User &&
(emojis.Contains(x.Emoji))).ConfigureAwait(false);
if (ReactionResult.Result.Emoji == DiscordEmoji.FromName(ctx.Client, ":abc:"))
{
await SendSpellingInfo(ctx, message, profile, member);
}
else if (ReactionResult.Result.Emoji == DiscordEmoji.FromName(ctx.Client, ":joystick:"))
{
await SendGameIdInfo(ctx, message, profile, member);
}
else if (ReactionResult.Result.Emoji == DiscordEmoji.FromName(ctx.Client, ":gear:"))
{
await SendProfilePrefsInfo(ctx, message, profile, member);
}
else if (ReactionResult.Result.Emoji == DiscordEmoji.FromName(ctx.Client, ":smiley:"))
{
await SendBasicInfo(ctx, message, profile, member);
}
else if (ReactionResult.Result.Emoji == DiscordEmoji.FromName(ctx.Client, ":scroll:"))
{
await SendUserInventory(ctx, message, profile, member);
}
else if (ReactionResult.Result.Emoji == DiscordEmoji.FromName(ctx.Client, ":shopping_cart:"))
{
await showShop(ctx, message, profile, member);
}
}
catch
{ await message.DeleteAllReactionsAsync(); }
}
public async Task SendSpellingInfo(CommandContext ctx, DiscordMessage message, Profile profile, DiscordMember member)
{
await message.DeleteAllReactionsAsync();
var profileEmbed = new DiscordEmbedBuilder
{
Title = $"{member.DisplayName}'s spelling stats.",
Thumbnail = new DiscordEmbedBuilder.EmbedThumbnail {
Url = member.AvatarUrl
},
Color = member.Color,
Timestamp = System.DateTime.Now
};
profileEmbed.AddField("Words Spelled Correctly:", profile.SpellCorrectCount.ToString(), true);
profileEmbed.AddField("Words Spelled Incorrectly:", profile.SpellErrorCount.ToString(), true);
profileEmbed.AddField("Spelling Accuracy:", profile.SpellAcc.ToString() + " %", true);
profileEmbed.AddField("Most Recent Spelling Mistakes (not working):", profile.SpellErrorList.ToString(), true);
profileEmbed.WithFooter("Please use `w!addtodictionary` if you wish, don't abuse, you will be black listed from the command.");
await message.ModifyAsync(content : " ", embed : profileEmbed.Build());
var emojiList = new List <DiscordEmoji>();
emojiList.Add(DiscordEmoji.FromName(ctx.Client, ":smiley:"));
emojiList.Add(DiscordEmoji.FromName(ctx.Client, ":joystick:"));
emojiList.Add(DiscordEmoji.FromName(ctx.Client, ":gear:"));
emojiList.Add(DiscordEmoji.FromName(ctx.Client, ":scroll:"));
if (member.Id == ctx.Member.Id)
{
emojiList.Add(DiscordEmoji.FromName(ctx.Client, ":shopping_cart:"));
}
foreach (var emoji in emojiList)
{
await message.CreateReactionAsync(emoji);
}
await AwaitReaction(ctx, message, profile, member, emojiList).ConfigureAwait(false);
}
private async Task UpdateRolePost(CommandArgs <RoleBotConfig> args)
{
if (args.Config.RolePostChannelID != 0 && args.Config.RolePostID != 0)
{
DiscordChannel channel = args.Guild.GetChannel(args.Config.RolePostChannelID);
DiscordMessage message = await channel?.GetMessageAsync(args.Config.RolePostID);
if (message != null)
{
await message.ModifyAsync(FormatRolePost(args.Guild, args.Config));
await message.DeleteAllReactionsAsync();
foreach (var emojiRole in args.Config.EmojiRoles)
{
DiscordEmoji emoji = DiscordEmoji.FromName(Instance.Client, emojiRole.Key);
await message.CreateReactionAsync(emoji);
}
}
}
}
internal static async Task BotClientMessageDeleted(MessageDeleteEventArgs e)
{
if (e.Channel.Id == Program.Settings.RimboardChannelId)
{
// Be warned: OriginalReactCount is always equal to -1.
PinInfo pinInfo = await QueryPinInfoFromRimboardId(e.Message.Id);
if (!pinInfo.Equals(PinInfo.Invalid))
{
// Get the channels.
DiscordChannel originalChannel = e.Guild.GetChannel(pinInfo.OriginalChannelId);
DiscordMessage originalMessage = await originalChannel.GetMessageAsync(pinInfo.OriginalMessageId);
var a = originalMessage.DeleteAllReactionsAsync();
var b = RemovePinFromDatabase(pinInfo);
await Task.WhenAll(a, b);
}
}
}
// ########### top profile tasks ##############
public async Task AwaitTopReaction(CommandContext ctx, DiscordMessage message, List <Profile> profiles, DiscordMember member, List <DiscordEmoji> emojis)
{
try
{
var interactivity = ctx.Client.GetInteractivity();
foreach (var emoji in emojis)
{
await message.CreateReactionAsync(emoji);
}
var ReactionResult = await interactivity.WaitForReactionAsync(
x => x.Message == message &&
x.User == ctx.User &&
(emojis.Contains(x.Emoji))).ConfigureAwait(false);
if (ReactionResult.Result.Emoji == DiscordEmoji.FromName(ctx.Client, ":moneybag:"))
{
await SendTopGold(ctx, message, profiles, member);
}
else if (ReactionResult.Result.Emoji == DiscordEmoji.FromName(ctx.Client, ":abc:"))
{
await SendTopSpelling(ctx, message, profiles, member);
}
else if (ReactionResult.Result.Emoji == DiscordEmoji.FromName(ctx.Client, ":regional_indicator_x:"))
{
await SendTopXp(ctx, message, profiles, member);
}
else if (ReactionResult.Result.Emoji == DiscordEmoji.FromName(ctx.Client, ":gotem:"))
{
await SendTopGots(ctx, message, profiles, member);
}
else if (ReactionResult.Result.Emoji == DiscordEmoji.FromName(ctx.Client, ":beer:"))
{
await SendTopBogan(ctx, message, profiles, member);
}
}
catch
{ await message.DeleteAllReactionsAsync(); }
}
