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 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 static async Task <PolarReactionState> polarReaction(CommandContext ctx, DiscordMessage mes)
{
await mes.CreateReactionAsync(DiscordEmoji.FromName(ctx.Client, ":white_check_mark:"));
await mes.CreateReactionAsync(DiscordEmoji.FromName(ctx.Client, ":x:"));
// var collectedReactions = await mes.CollectReactionsAsync(TimeSpan.FromSeconds(60));
// System.Collections.ObjectModel.ReadOnlyCollection<DSharpPlus.Interactivity.EventHandling.Reaction> collectedReactions;
System.Collections.ObjectModel.ReadOnlyCollection <DSharpPlus.Interactivity.EventHandling.Reaction> collectedReactions;
IEnumerable <DSharpPlus.Interactivity.EventHandling.Reaction> result = null;
AsyncBinder checkReaction = async() => {
collectedReactions = await mes.CollectReactionsAsync(TimeSpan.FromMilliseconds(500));
result = collectedReactions.Where(r => new string[] { ":white_check_mark:", ":x:" }.Contains(r.Emoji.GetDiscordName()) && r.Users.Contains(ctx.Message.Author));
return(result.Count() > 0);
};
await asyncExecuteFor(() => checkReaction(), TimeSpan.FromSeconds(60));
if (result != null)
{
if (result.FirstOrDefault(r => r.Emoji.GetDiscordName() == ":white_check_mark:") != null)
{
return(PolarReactionState.Yes);
}
else
{
return(PolarReactionState.No);
}
}
else
{
return(PolarReactionState.TimedOut);
}
}
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 InitPaginationAsync(DiscordMessage message, CacheContentType contentType, string parameter)
{
using (var databaseContext = new DatabaseContext())
{
var paginatedMessage = new PaginatedMessage
{
GuildId = message.Channel.GuildId.ToString(),
MessageId = message.Id.ToString(),
ContentType = contentType,
Parameter = parameter,
CurrentPage = 1
};
await databaseContext.PaginatedMessages.AddAsync(paginatedMessage);
await databaseContext.SaveChangesAsync();
}
await message.CreateReactionAsync(DiscordEmoji.FromName(Bot.Client, FirstEmojiName));
await message.CreateReactionAsync(DiscordEmoji.FromName(Bot.Client, LeftEmojiName));
await message.CreateReactionAsync(DiscordEmoji.FromName(Bot.Client, RightEmojiName));
await message.CreateReactionAsync(DiscordEmoji.FromName(Bot.Client, LastEmojiName));
_logger.Info($"New pagination for {contentType} added");
}
public static async Task <bool> PromptUserToConfirm(CommandContext Context, string PromptMessage, bool bDeleteOnComplete = true)
{
var Interactivity = Context.Client.GetExtension <InteractivityExtension>();
await Context.TriggerTypingAsync();
DiscordMessage Msg = await Context.RespondAsync(PromptMessage);
await Msg.CreateReactionAsync(DiscordEmoji.FromName(Context.Client, ":white_check_mark:"));
await Msg.CreateReactionAsync(DiscordEmoji.FromName(Context.Client, ":x:"));
var ReactContext = await Interactivity.WaitForReactionAsync(x => x.Emoji.Name == "✅" || x.Emoji.Name == "❌", Msg, Context.User);
if (bDeleteOnComplete)
{
await Msg.DeleteAsync();
}
if (ReactContext.Result != null && ReactContext.Result.Emoji.Name == "✅")
{
return(true);
}
return(false);
}
//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:"));
}
}
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);
}
private async Task OnGuildAvailable(DiscordClient dClient, GuildCreateEventArgs args)
{
if (args.Guild.Id != Guilds.Bloon)
{
return;
}
await this.dClient.Guilds[Guilds.Bloon].GetEmojisAsync();
DiscordChannel settingsChannel = await this.dClient.GetChannelAsync(BloonChannels.Settings);
IReadOnlyList <DiscordMessage> messages = await settingsChannel.GetMessagesAsync(this.featureManager.Features.Count);
for (int i = 0; i < this.featureManager.Features.Count; i++)
{
Feature feature = this.featureManager.Features[i];
DiscordMessage message = messages.Where(m => m.Embeds[0]?.Title == feature.Name).FirstOrDefault();
DiscordEmbed newEmbed = CreateFeatureEmbed(feature);
if (message == null)
{
message = await settingsChannel.SendMessageAsync(embed : newEmbed);
await message.CreateReactionAsync(DiscordEmoji.FromGuildEmote(this.dClient, FeatureEmojis.ToggleOff));
await message.CreateReactionAsync(DiscordEmoji.FromGuildEmote(this.dClient, FeatureEmojis.ToggleOn));
}
else if (!IdenticalEmbed(message.Embeds[0], newEmbed))
{
await message.ModifyAsync(embed : newEmbed);
}
}
}
public async Task ClosedPollThreeOption(CommandContext ctx, [RemainingText] string message)
{
string[] embedTitle = message.Split('|');
string embedMessage = string.Empty;
embedMessage += $"{DiscordEmoji.FromGuildEmote(ctx.Client, Variables.Emojis.Polls.Yes)} **Yes**\n";
embedMessage += $"{DiscordEmoji.FromGuildEmote(ctx.Client, Variables.Emojis.Polls.No)} **No**\n";
embedMessage += $"{DiscordEmoji.FromName(ctx.Client, ":regional_indicator_m:")} **Maybe**\n";
DiscordEmbed pollEmbed = new DiscordEmbedBuilder
{
Footer = new DiscordEmbedBuilder.EmbedFooter
{
IconUrl = DiscordEmoji.FromGuildEmote(ctx.Client, Variables.Emojis.Polls.InfoIcon).Url,
Text = "Vote using reactions",
},
Color = new DiscordColor(250, 250, 250),
Timestamp = DateTime.UtcNow,
Title = $"**{embedTitle[0]}**",
Description = embedMessage,
};
DiscordMessage reactionMessage = await ctx.Channel.SendMessageAsync(embed : pollEmbed);
await reactionMessage.CreateReactionAsync(DiscordEmoji.FromGuildEmote(ctx.Client, Variables.Emojis.Polls.Yes));
await reactionMessage.CreateReactionAsync(DiscordEmoji.FromGuildEmote(ctx.Client, Variables.Emojis.Polls.No));
await reactionMessage.CreateReactionAsync(DiscordEmoji.FromName(ctx.Client, ":regional_indicator_m:"));
}
public async Task <ReactionCollectionContext> CreatePollAsync(DiscordMessage m, TimeSpan timeout, List <DiscordEmoji> Emojis)
{
foreach (var em in Emojis)
{
await m.CreateReactionAsync(em);
}
var rcc = new ReactionCollectionContext();
var tsc = new TaskCompletionSource <ReactionCollectionContext>();
var ct = new CancellationTokenSource(timeout);
ct.Token.Register(() => tsc.TrySetResult(rcc));
AsyncEventHandler <MessageReactionAddEventArgs> handler1 = async(e) =>
{
await Task.Yield();
if (e.Message.Id == m.Id && Emojis.Count(x => x == e.Emoji) > 0)
{
rcc.AddReaction(e.Emoji, e.User.Id);
}
};
this.Client.MessageReactionAdded += handler1;
AsyncEventHandler <MessageReactionRemoveEventArgs> handler2 = async(e) =>
{
await Task.Yield();
if (e.Message.Id == m.Id && Emojis.Count(x => x == e.Emoji) > 0)
{
rcc.RemoveReaction(e.Emoji, e.User.Id);
}
};
this.Client.MessageReactionRemoved += handler2;
AsyncEventHandler <MessageReactionsClearEventArgs> handler3 = async(e) =>
{
await Task.Yield();
if (e.Message.Id == m.Id)
{
rcc.ClearReactions();
foreach (var em in Emojis)
{
await m.CreateReactionAsync(em);
}
}
};
this.Client.MessageReactionsCleared += handler3;
var result = await tsc.Task;
this.Client.MessageReactionAdded -= handler1;
this.Client.MessageReactionRemoved -= handler2;
this.Client.MessageReactionsCleared -= handler3;
return(result);
}
public async Task ClearEmoji(CommandContext c)
{
if (c.Guild == null)
{
throw new InvalidOperationException("You cannot modify emojis in a DM.");
}
InteractivityModule i = c.Client.GetInteractivityModule();
IReadOnlyList <DiscordGuildEmoji> emojis = await c.Guild.GetEmojisAsync();
if (!emojis.Any())
{
await c.RespondAsync("You have no emoji on this server to remove.");
return;
}
DiscordMessage m = await c.RespondAsync("Are you sure that you want to clear all emoji from this server?");
await m.CreateReactionAsync(Reactions.YES);
await m.CreateReactionAsync(Reactions.NO);
ReactionContext react = await i.WaitForReactionAsync(x => x == Reactions.YES || x == Reactions.NO, c.User,
TimeSpan.FromSeconds(30));
await m.DeleteAsync();
if (react != null)
{
if (react.Message == m)
{
DiscordMessage clear = await c.RespondAsync("Alright, I'm clearing all of the emojis on this server... This will take a couple of minutes due to Discord's ratelimits.");
foreach (DiscordGuildEmoji e in emojis)
{
try { await c.Guild.DeleteEmojiAsync(e); }
catch (BadRequestException)
{
await c.RespondAsync("I failed to delete the emoji. Discord gave me a bad response.");
return;
}
}
await clear.ModifyAsync("I've cleared all of the emojis on this server.");
}
else
{
await c.RespondAsync("You did not react to the original message. Aborting.");
return;
}
}
else
{
await c.RespondAsync("No response was given. Aborting.");
}
}
public async Task AddPendingGame(CommandContext ctx, DiscordMessage msg, PendingGame game)
{
await msg.CreateReactionAsync(DiscordEmoji.FromName(ctx.Client, Reactions.OK));
await msg.CreateReactionAsync(DiscordEmoji.FromName(ctx.Client, Reactions.NO));
PendingGames.Add(msg.Id, game);
}
public async Task Execute()
{
Log.Information("Checking Helprace for new posts..");
HelpracePost post = await this.helpraceService.GetLatestAsync("all_topics");
// Unable to fetch the latest post from helprace
if (post == null)
{
this.bloonLog.Error($"Something went wrong fetching the latest helprace post! Check Log File");
return;
}
else if (!await this.helpraceService.TryStoreNewAsync(post))
{
Log.Information("Finished Helprace checks early");
return;
}
DiscordChannel sbgBugs = await this.dClient.GetChannelAsync(SBGChannels.Bugs);
if (post.Title.Length > 128)
{
post.Title = post.Title.Truncate(128) + "...";
}
if (post.Body.Length > 256)
{
post.Body = post.Body.Truncate(256) + $"... [Read more](https://superbossgames.helprace.com/i{post.UID})";
}
DiscordEmbed hrEmbed = new DiscordEmbedBuilder
{
Author = new DiscordEmbedBuilder.EmbedAuthor
{
Name = post.Author,
Url = $"https://superbossgames.helprace.com/i{post.UID}",
},
Footer = new DiscordEmbedBuilder.EmbedFooter
{
IconUrl = DiscordEmoji.FromGuildEmote(this.dClient, PlatformEmojis.Helprace).Url,
Text = $"Helprace | Channel: {post.Channel.Replace("ideas", "Suggestions", StringComparison.Ordinal).Replace("problems", "Bugs", StringComparison.Ordinal)}",
},
Color = new DiscordColor(23, 153, 177),
Timestamp = post.Timestamp,
Title = post.Title,
Description = post.Body,
Url = $"https://superbossgames.helprace.com/i{post.UID}",
};
DiscordMessage message = await sbgBugs.SendMessageAsync(embed : hrEmbed);
await message.CreateReactionAsync(DiscordEmoji.FromGuildEmote(this.dClient, ReputationEmojis.Up));
await message.CreateReactionAsync(DiscordEmoji.FromGuildEmote(this.dClient, ReputationEmojis.Down));
Log.Information("Finished Helprace Scraping");
}
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();
}
internal static async Task MessagesUpdateAsync(DiscordMessage mess)
{
Duel d = duels.Find(cd => mess == cd);
if (d != null)
{
if (d.duel.flag)
{
await mess.DeleteAsync();
return;
}
DiscordMessage mess1 = null, mess2 = null;
try { mess1 = await mess.Channel.GetMessageAsync(d.duel.message1); } catch { }
try { mess2 = await mess.Channel.GetMessageAsync(d.duel.message2); } catch { }
if (mess1?.Author.Id == mess.Author.Id)
{
await mess1.DeleteAsync();
}
else if (mess2?.Author.Id == mess.Author.Id)
{
await mess2.DeleteAsync();
}
if (mess.Author.Id == d.duel.duelist1)
{
d.duel.message1 = mess.Id;
}
else
{
d.duel.message2 = mess.Id;
}
await d.UpdateAsync();
await mess.CreateReactionAsync(await mess.Channel.Guild.GetEmojiAsync(604972398424621066u));
await mess.CreateReactionAsync(await mess.Channel.Guild.GetEmojiAsync(604973811154288660u));
if (!IsDuelReactionAdded)
{
Program.bot.MessageReactionAdded += DuelReactionsAdded;
IsDuelReactionAdded = true;
}
}
else
{
await mess.DeleteAsync();
}
}
public async Task GeneratePaginationReactions(DiscordMessage m)
{
await m.CreateReactionAsync(DiscordEmoji.FromUnicode(this.Client, "⏮"));
await m.CreateReactionAsync(DiscordEmoji.FromUnicode(this.Client, "◀"));
await m.CreateReactionAsync(DiscordEmoji.FromUnicode(this.Client, "⏹"));
await m.CreateReactionAsync(DiscordEmoji.FromUnicode(this.Client, "▶"));
await m.CreateReactionAsync(DiscordEmoji.FromUnicode(this.Client, "⏭"));
}
/// <summary>
/// initializes the private data for the lobby
/// </summary>
/// <param name="context">the command context from which the lobby will be initialized</param>
/// <returns></returns>
public async Task<LobbyInitializationResult> Initialize(CommandContext context)
{
Context = context;
_EmbedBuilder.Author = new DiscordEmbedBuilder.EmbedAuthor
{
IconUrl = Context.User.AvatarUrl
};
foreach (var player in _Players)
{
if (!CheckIfEmojiExistsOnServer(player.Emoji.DiscordEmojiAlive) || !CheckIfEmojiExistsOnServer(player.Emoji.DiscordEmojiDead))
return LobbyInitializationResult.MissingEmoji;
player.Alive = DiscordEmoji.FromName(Context.Client, player.Emoji.DiscordEmojiAlive);
player.Dead = DiscordEmoji.FromName(Context.Client, player.Emoji.DiscordEmojiDead);
_ValidReactEmojis.Add(player.Alive);
}
CurrentGameStatus = await UpdateGameState(GameState.StartUp, null);
_EmbedMessage = await Context.Channel.SendMessageAsync(embed: _EmbedBuilder);
_ToBeDeletedMessages.Add(_EmbedMessage);
if (!CheckIfEmojiExistsOnServer(_Configuration.LeaveLobbyEmojiName))
return LobbyInitializationResult.MissingEmoji;
if (!CheckIfEmojiExistsOnServer(_Configuration.PlayPauseEmojiName))
return LobbyInitializationResult.MissingEmoji;
if (!CheckIfEmojiExistsOnServer(_Configuration.EndGameEmojiName))
return LobbyInitializationResult.MissingEmoji;
_LeaveLobby = DiscordEmoji.FromName(Context.Client, _Configuration.LeaveLobbyEmojiName);
_PlayGame = DiscordEmoji.FromName(Context.Client, _Configuration.PlayPauseEmojiName);
_StopGame = DiscordEmoji.FromName(Context.Client, _Configuration.EndGameEmojiName);
_ValidReactEmojis.AddRange(_LeaveLobby, _PlayGame, _StopGame);
await _EmbedMessage.CreateReactionAsync(_PlayGame);
await _EmbedMessage.CreateReactionAsync(_StopGame);
foreach (var player in _Players)
{
await _EmbedMessage.CreateReactionAsync(player.Alive);
await Task.Delay(250);
}
await _EmbedMessage.CreateReactionAsync(_LeaveLobby);
_Interactivity = Context.Client.GetInteractivity();
CurrentGameStatus = await UpdateGameState(GameState.InLobby, null);
return LobbyInitializationResult.Success;
}
private Task WoteAsync(DiscordMessage message, bool dunno = false)
{
message.CreateReactionAsync(DiscordEmoji.FromName(Client, ":white_check_mark:"));
HelperMethods.Delay();
message.CreateReactionAsync(DiscordEmoji.FromName(Client, ":x:"));
if (dunno)
{
HelperMethods.Delay();
message.CreateReactionAsync(DiscordEmoji.FromGuildEmote(Client, 614346797141458974));
}
return(Task.CompletedTask);
}
public static async Task AddEmotions(DiscordClient discord, DiscordMessage message)
{
await message.CreateReactionAsync(DiscordEmoji.FromName(discord, GetEmoji.EmojiOne)).ConfigureAwait(false);
await message.CreateReactionAsync(DiscordEmoji.FromName(discord, GetEmoji.EmojiTwo)).ConfigureAwait(false);
await message.CreateReactionAsync(DiscordEmoji.FromName(discord, GetEmoji.EmojiThree)).ConfigureAwait(false);
await message.CreateReactionAsync(DiscordEmoji.FromName(discord, GetEmoji.EmojiFour)).ConfigureAwait(false);
await message.CreateReactionAsync(DiscordEmoji.FromName(discord, GetEmoji.EmojiFive)).ConfigureAwait(false);
return;
}
protected async Task AddReactionButton(DiscordEmoji emoji, UIAction pressedAction)
{
await message.CreateReactionAsync(emoji);
Flipper.Bot.MessageReactionAdded += async args =>
{
if (args.Message == message && args.Emoji == emoji && args.User != Flipper.Bot.CurrentUser)
{
var press = pressedAction(args.ToUIActionArgs());
var delete = message.DeleteReactionAsync(emoji, args.User);
await Task.WhenAll(press, delete);
}
};
}
public async Task Vote(CommandContext ctx, [Description("What to vote about?")][RemainingText] string topic)
{
await ctx.Message.DeleteAsync();
DiscordMessage msg = await new DiscordMessageBuilder()
.WithContent(topic)
.SendAsync(ctx.Channel);
DiscordEmoji up = DiscordEmoji.FromName(ctx.Client, ":thumbsup:");
DiscordEmoji down = DiscordEmoji.FromName(ctx.Client, ":thumbsdown:");
await msg.CreateReactionAsync(up);
await Task.Delay(500);
await msg.CreateReactionAsync(down);
}
private static async Task Waifunator(DiscordMessage message)
{
if (!string.IsNullOrWhiteSpace(message.Content) && message.Author.Id.Equals(Settings.Default.limid) && message.Content.Contains("wife", StringComparison.OrdinalIgnoreCase))
{
await message.CreateReactionAsync(DiscordEmoji.FromName(SekiMain.DiscordClient, ":regional_indicator_w:")).ConfigureAwait(false);
await message.CreateReactionAsync(DiscordEmoji.FromName(SekiMain.DiscordClient, ":regional_indicator_a:")).ConfigureAwait(false);
await message.CreateReactionAsync(DiscordEmoji.FromName(SekiMain.DiscordClient, ":regional_indicator_i:")).ConfigureAwait(false);
await message.CreateReactionAsync(DiscordEmoji.FromName(SekiMain.DiscordClient, ":regional_indicator_f:")).ConfigureAwait(false);
await message.CreateReactionAsync(DiscordEmoji.FromName(SekiMain.DiscordClient, ":regional_indicator_u:")).ConfigureAwait(false);
}
}
public static async Task CreateReactionsBulk(this DiscordMessage msg, string[] reactions)
{
foreach (var reaction in reactions)
{
await msg.CreateReactionAsync(DiscordEmoji.FromUnicode(reaction));
}
}
private async Task SendReactions(DiscordMessage message, int missCount)
{
for (int i = 1; i < Math.Min(missCount + 1, ServerContext.numberEmojis.Length); i++)
{
await message.CreateReactionAsync(ServerContext.numberEmojis[i]);
}
}
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);
}
}
}
/// <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()));
}
private async Task AddReactions(DiscordClient client, DiscordMessage message)
{
foreach (string emoji in _optionsEmoji.Take(_options.Count))
{
await message.CreateReactionAsync(DiscordEmoji.FromName(client, emoji));
}
}
private async Task Initialize(DiscordMessage message, int pageNum)
{
if (Pages > 1)
{
await message.CreateReactionAsync(DiscordEmoji.FromUnicode(Left));
await message.CreateReactionAsync(DiscordEmoji.FromUnicode(Stop));
await message.CreateReactionAsync(DiscordEmoji.FromUnicode(Right));
}
else
{
await message.CreateReactionAsync(DiscordEmoji.FromUnicode(Stop));
}
await Pagination(message, pageNum);
}
/// <summary>
/// This will detect if a message within the SBG guild contains a word that is stored in the naughtywords file.
/// </summary>
/// <param name="args">Message arguments.</param>
/// <returns>Profantiy warning to AUG chat.</returns>
private async Task CensorAsync(DiscordClient dClient, MessageCreateEventArgs args)
{
if (args.Author.IsBot)
{
return;
}
if (this.censorer.TryCensorContent(args.Message.Content, out string censored, out KeyValuePair <int, Regex> censor))
{
DiscordChannel sbgMod = args.Message.Channel.Guild.GetChannel(SBGChannels.Bloonside);
DiscordEmbedBuilder embed = new DiscordEmbedBuilder
{
Color = new DiscordColor(255, 0, 0),
Description = $"\"{censored}\"",
Timestamp = args.Message.Timestamp,
Title = $"**Censor**",
};
embed.AddField("Author", args.Message.Author.Mention, true);
embed.AddField("Pattern", $"`{censor.Value}` (Id: {censor.Key})", true);
embed.AddField("Original Message", $"[Click Here]({args.Message.JumpLink})", true);
DiscordMessage embedMessage = await sbgMod.SendMessageAsync(embed);
await embedMessage.CreateReactionAsync(DiscordEmoji.FromName(this.dClient, ":wastebasket:"));
}
}
