private async Task CreatureReactionHandler(IUserMessage message, ISocketMessageChannel channel, SocketReaction reaction, IUser user)
{
var CreatureHelperEmbed = message.Embeds.FirstOrDefault(embed => embed?.Title?.Contains(CreatureResources.CreatureHelper) ?? false);
if (CreatureHelperEmbed != null)
{
CreatureEnvironment environment = StarforgedUtilites.CreatureEnvironmentFromEmote(reaction.Emote.Name);
if (reaction.Emote.IsSameAs(randomEmoji))
{
string lookupValue = Services.GetRequiredService <OracleService>().RandomRow("Creature Environment").Description;
environment = StarforgedUtilites.GetAnyEnvironment(lookupValue);
}
if (environment == CreatureEnvironment.None)
{
return;
}
var newCreature = Creature.GenerateNewCreature(Services, channel.Id, environment);
Task.WaitAll(message.RemoveAllReactionsAsync());
await message.ModifyAsync(msg =>
{
msg.Content = string.Empty;
msg.Embed = newCreature.GetEmbedBuilder().Build();
}).ConfigureAwait(false);
await Task.Run(async() =>
{
if (message.Reactions.Count > 0)
{
await Task.Delay(1500); //wait just in case we are still adding more reactions. Impatient users deserve to wait!!!
await message.RemoveAllReactionsAsync();
}
await message.AddReactionAsync(revealAspectEmoji).ConfigureAwait(false);
}).ConfigureAwait(false);
return;
}
var creatureEmbed = message.Embeds.FirstOrDefault(embed => embed?.Title?.Contains(CreatureResources.CreatureTitle) ?? false);
if (creatureEmbed == null)
{
return;
}
var creature = Creature.FromEmbed(creatureEmbed, Services, channel.Id);
if (reaction.Emote.IsSameAs(revealAspectEmoji))
{
creature.AddRandomAspect();
}
await message.ModifyAsync(msg => msg.Embed = creature.GetEmbedBuilder().Build()).ConfigureAwait(false);
await message.RemoveReactionAsync(reaction.Emote, user).ConfigureAwait(false);
return;
}
private void RunSafari(EmbedBuilder embed, IUserMessage msg, Card newCard,
SafariImage pokeImage, ICharacterInfo character, ITextChannel trashChannel)
{
_ = Task.Run(async() =>
{
try
{
await Task.Delay(TimeSpan.FromMinutes(5));
var usersReacted = await msg.GetReactionUsersAsync(ClaimEmote, 300).FlattenAsync();
var users = usersReacted.ToList();
IUser winner = null;
using (var db = new Database.UserContext(_config))
{
var watch = Stopwatch.StartNew();
while (winner == null)
{
if (watch.ElapsedMilliseconds > 60000)
{
throw new Exception("Timeout");
}
if (users.Count < 1)
{
embed.Description = $"Na polowanie nie stawił się żaden łowca!";
await msg.ModifyAsync(x => x.Embed = embed.Build());
return;
}
var selected = Fun.GetOneRandomFrom(users);
var dUser = await db.GetCachedFullUserAsync(selected.Id);
if (dUser != null)
{
if (!dUser.IsBlacklisted)
{
winner = selected;
}
}
else
{
users.Remove(selected);
}
}
}
var exe = GetSafariExe(embed, msg, newCard, pokeImage, character, trashChannel, winner);
await _executor.TryAdd(exe, TimeSpan.FromSeconds(1));
await msg.RemoveAllReactionsAsync();
}
catch (Exception ex)
{
_logger.Log($"In Safari: {ex}");
await msg.ModifyAsync(x => x.Embed = "Karta uciekła!".ToEmbedMessage(EMType.Error).Build());
await msg.RemoveAllReactionsAsync();
}
});
}
public static async Task PvPMainMenu(UserAccount user, IUserMessage message, IEmote emote, ContextIds idList)
{
switch (emote.Name.ToLower())
{
case "back1":
user.RemoveAllReactionMessages(11);
user.RemoveAllReactionMessages(1);
await message.RemoveAllReactionsAsync();
await message.ModifyAsync(m => { m.Embed = MonEmbedBuilder.MainMenu(user); m.Content = ""; });
await MessageHandler.MenuEmojis(message);
user.ReactionMessages.Add(message.Id, 1);
break;
case "singlebattle":
user.RemoveAllReactionMessages(12);
user.RemoveAllReactionMessages(11);
user.RemoveAllReactionMessages(1);
CombatCreationTool lobby = user.GetOrCreatePvPLobby("single", user.UserId);
await message.RemoveAllReactionsAsync();
string url = MessageHandler.GetImageURL(ImageGenerator.PvPSoloLobby(lobby)).Result;
await message.ModifyAsync(m => { m.Embed = MonEmbedBuilder.PvPLobby(lobby, url, user); m.Content = ""; });
await MessageHandler.PvPLobbyEmojis(message, user);
user.ReactionMessages.Add(message.Id, 12);
break;
case "doublebattle":
await MessageHandler.NotImplemented(idList, "double battle");
break;
case "ffa":
await MessageHandler.NotImplemented(idList, "free for all");
break;
case "custombattle":
await MessageHandler.NotImplemented(idList, "custom battle");
break;
default:
break;
}
}
public static async Task CreateTeamMenu(UserAccount user, IUserMessage message, IEmote emote, ContextIds idList)
{
switch (emote.Name.ToLower())
{
case "back1":
user.RemoveAllReactionMessages(9);
user.RemoveAllReactionMessages(1);
await message.RemoveAllReactionsAsync();
await message.ModifyAsync(m => { m.Embed = MonEmbedBuilder.MainMenu(user); m.Content = ""; });
await MessageHandler.MenuEmojis(message);
user.ReactionMessages.Add(message.Id, 1);
break;
case "team":
Team t = new Team(true);
t.AddMember(user);
TownHandler.GetTown(user.Char.CurrentGuildId).Teams.Add(t);
if (user.ExpectedInput == 5)
{
user.ExpectedInput = -1;
user.ExpectedInputLocation = 0;
}
user.RemoveAllReactionMessages(9);
user.RemoveAllReactionMessages(7);
await message.RemoveAllReactionsAsync();
await message.ModifyAsync(m => { m.Embed = MonEmbedBuilder.TeamMenu(user); m.Content = ""; });
await MessageHandler.TeamMenuEmojis(message, user);
break;
case "invite":
await message.ModifyAsync(m => { m.Content = "**Tag someone in the team you want to join. The team must be open.**"; });
user.ExpectedInput = 5;
user.ExpectedInputLocation = message.Channel.Id;
break;
default:
break;
}
}
protected async Task RedrawBattle()
{
autoTurn.Stop();
wasJustReset = false;
Task.WaitAll(PlayerMessages.Select(m => m.Key.RemoveAllReactionsAsync())
.Append(EnemyMessage.RemoveAllReactionsAsync())
.Append(SummonsMessage.RemoveAllReactionsAsync())
.ToArray()
);
await WriteBattleInit();
autoTurn.Start();
}
private static async void PlayDealerHand(IUserMessage message, SocketGuildChannel guildChannel, SocketReaction reaction)
{
// No active game, no handling
if (activeGame == null)
{
return;
}
// Show dealer's second card
await message.ModifyAsync(x => x.Embed = GetEmbedBuilder(true).Build());
while (!activeGame.DealerIsStanding)
{
activeGame.DealCardToDealer();
await message.ModifyAsync(x => x.Embed = GetEmbedBuilder(true).Build());
}
// Payout
if (activeGame.UserWon)
{
User user = await UserService.GetUser(guildChannel.Guild.Id, reaction.UserId);
int payout = activeGame.Payout();
Log.Write("User (" + activeGame.UserId.ToString() + ") won " + payout.ToString() + " nuts with a game of Black Jack", "Bot - Blackjack");
user.UpdateTotalKupoNuts(payout);
}
// Game finished - Perform last build, remove reactions, and clear active game
await message.ModifyAsync(x => x.Embed = GetEmbedBuilder(true, true).Build());
await message.RemoveAllReactionsAsync();
activeGame = null;
}
private async Task SettlementReactionHandler(IUserMessage message, ISocketMessageChannel channel, SocketReaction reaction, IUser user)
{
var settlementHelperEmbed = message.Embeds.FirstOrDefault(embed => embed?.Title?.Contains(SettlementResources.SettlementHelper) ?? false);
if (settlementHelperEmbed != null)
{
var region = StarforgedUtilites.SpaceRegionFromEmote(reaction.Emote.Name);
if (region == SpaceRegion.None)
{
return;
}
string command = settlementHelperEmbed.Fields.FirstOrDefault(fld => fld.Name == SettlementResources.SettlementName).Value ?? string.Empty;
string location = ExtractAnySettlementLocation(ref command);
var newSettlement = Settlement.GenerateSettlement(Services, region, channel.Id, command, location);
Task.WaitAll(message.RemoveAllReactionsAsync());
await message.ModifyAsync(msg =>
{
msg.Content = string.Empty;
msg.Embed = newSettlement.GetEmbedBuilder().Build();
}).ConfigureAwait(false);
await Task.Run(async() =>
{
await message.AddReactionAsync(projectEmoji);
await message.AddReactionAsync(contactEmoji);
await message.AddReactionAsync(troubleEmoji);
}).ConfigureAwait(false);
return;
}
}
public static async Task HandleReactionMessage(ISocketMessageChannel channel, SocketSelfUser botUser, SocketReaction reaction, IUserMessage message)
{
if (message.Author.Id == botUser.Id && reaction.UserId != botUser.Id)
{
var reactionMessage = GetReactionMessageById(message.Id);
if (reactionMessage != null && reaction.UserId == reactionMessage.Context.User.Id && (reactionMessage.AcceptsAllReactions || reactionMessage.AcceptedReactions.Contains(reaction.Emote.ToString())))
{
try
{
await reactionMessage.RunAction(reaction.Emote);
}
catch (Exception ex)
{
await ExceptionMessageHelper.HandleException(ex, channel);
}
if (reactionMessage.AllowMultipleReactions)
{
await message.RemoveReactionAsync(reaction.Emote, reactionMessage.Context.User);
}
else
{
await message.RemoveAllReactionsAsync();
DeleteReactionMessage(reactionMessage);
}
}
else if (reactionMessage != null && reaction.User.IsSpecified)
{
await message.RemoveReactionAsync(reaction.Emote, reaction.User.Value);
}
}
}
private async Task BuildProgressTrackerPostAsync(ChallengeRank cr, string ThingToTrack, IUserMessage messageToEdit = null)
{
if (messageToEdit == null)
{
var tracker = new ProgressTrackerInfo(cr, ThingToTrack);
messageToEdit = ReplyAsync(embed: tracker.BuildEmbed() as Embed).Result;
}
else
{
var tracker = new ProgressTrackerInfo().PopulateFromMessage(messageToEdit, cr);
await messageToEdit.ModifyAsync(msg =>
{
msg.Content = string.Empty;
msg.Embed = tracker.BuildEmbed() as Embed;
});
}
await messageToEdit.RemoveAllReactionsAsync();
_ = Task.Run(async() =>
{
await messageToEdit.AddReactionAsync(DecreaseEmoji);
await messageToEdit.AddReactionAsync(IncreaseEmoji);
await messageToEdit.AddReactionAsync(FullEmoji);
await messageToEdit.AddReactionAsync(RollEmoji);
await messageToEdit.AddReactionAsync(new Emoji(GenericReactions.recreatePostEmoji));
}).ConfigureAwait(false);
return;
}
private async Task HandleReactionInAdd(SocketReaction reaction, IUserMessage msg)
{
if (reaction.Emote.Equals(OneEmote) && reaction.UserId == P1.User.Id)
{
P1.Accepted = true;
RestartTimer();
}
else if (reaction.Emote.Equals(TwoEmote) && reaction.UserId == P2.User.Id)
{
P2.Accepted = true;
RestartTimer();
}
if (P1.Accepted && P2.Accepted)
{
State = ExchangeStatus.AcceptP1;
Tips = $"{P1.User.Mention} daj {AcceptEmote} aby zaakceptować, lub {DeclineEmote} aby odrzucić.";
await msg.RemoveAllReactionsAsync();
await msg.ModifyAsync(x => x.Embed = BuildEmbed());
await msg.AddReactionsAsync(new IEmote[] { AcceptEmote, DeclineEmote });
}
}
private async Task HandleMessage(IUserMessage msg, IEmote reaction)
{
Message mes = _messageRepo.GetMessage(msg.Id);
_messageRepo.RemoveMessage(mes.MessageID);
_messages.Remove(_messages.FirstOrDefault(m => m.MessageID == msg.Id));
Embed embeds = (Embed)msg.Embeds.First();
if (reaction.Name.Equals(cross.Name))
{
var changed = embeds.ToEmbedBuilder();
changed.Color = Color.Red;
await msg.RemoveAllReactionsAsync();
await msg.ModifyAsync(m => m.Embed = changed.Build());
return;
}
await msg.DeleteAsync();
Channel chan = _channelRepo.GetChannelByTypeInGuild(mes.Channel.GuildID, Models.Domain.ChannelType.publicfeed);
SocketGuild guild = _client.Guilds.FirstOrDefault(g => g.Id == chan.GuildID);
IMessageChannel channel = (IMessageChannel)guild.GetChannel(chan.ChanelID);
await channel.SendMessageAsync(embed : embeds);
}
private async Task MakePlanetPost(SpaceRegion region, string PlanetName, IUserMessage message = null)
{
Planet planet = Planet.GeneratePlanet(PlanetName, region, Services);
if (message != null)
{
await message.RemoveAllReactionsAsync();
await message.ModifyAsync(msg => msg.Embed = planet.GetEmbedBuilder().Build());
}
else
{
message = await ReplyAsync(embed : planet.GetEmbedBuilder().Build());
}
_ = Task.Run(async() =>
{
await message.AddReactionAsync(new Emoji("🔍"));
await message.AddReactionAsync(new Emoji("\U0001F996"));
if (planet.NumberOfBiomes > 1)
{
var biome = new Emoji("\uD83C\uDF0D");
await message.AddReactionAsync(biome);
}
}).ConfigureAwait(false);
}
/// <summary>
/// Executes the action in <paramref name="actionOnStop"/>.
/// </summary>
/// <param name="message">
/// The message.
/// </param>
/// <param name="actionOnStop">
/// The action to do.
/// </param>
public async Task OnStopAsync(IUserMessage message, ActionOnTimeout actionOnStop)
{
Interactive.RemoveReactionCallback(message);
switch (actionOnStop)
{
case ActionOnTimeout.DeleteMessage:
await message.DeleteAsync();
break;
case ActionOnTimeout.DeleteReactions:
bool manageMessages = message.Channel is SocketGuildChannel guildChannel &&
guildChannel.GetUser(message.Author.Id).GetPermissions(guildChannel).ManageMessages;
if (manageMessages)
{
await message.RemoveAllReactionsAsync();
}
else
{
await message.RemoveReactionsAsync(message.Author, message.Reactions.Where(x => x.Value.IsMe).Select(x => x.Key).ToArray());
}
break;
case ActionOnTimeout.Nothing:
default:
break;
}
}
private async Task ExecuteGameInputAsync(IReactionsGame game, SocketReaction reaction, IUserMessage message, ISocketMessageChannel channel)
{
var userId = reaction.UserId;
var user = reaction.User.GetValueOrDefault() ?? client.GetUser(reaction.UserId);
var guild = (channel as SocketTextChannel)?.Guild;
log.Verbose(
$"Input {reaction.Emote.ReadableName()} by {user?.FullName()} in {channel.FullName()}",
game.GameName);
await game.InputAsync(reaction.Emote, userId);
if (game.State != GameState.Active)
{
if (!(game is IUserGame))
{
games.Remove(game);
}
if (game is PacManGame pmGame && pmGame.State != GameState.Cancelled && !pmGame.custom)
{
storage.AddScore(new ScoreEntry(pmGame.score, userId, pmGame.State, pmGame.Time,
user?.NameandDisc(), $"{guild?.Name}/{channel.Name}", DateTime.Now));
}
if (channel.BotCan(ChannelPermission.ManageMessages))
{
await message.RemoveAllReactionsAsync(PmBot.DefaultOptions);
}
}
game.CancelRequests();
try { await message.ModifyAsync(game.GetMessageUpdate(), game.GetRequestOptions()); }
catch (OperationCanceledException) { }
}
private async Task HelperHandler(IUserMessage message, ISocketMessageChannel channel, SocketReaction reaction, IUser user)
{
if (!message?.Embeds?.Any(embed => embed.Title == OracleResources.AskOracleHelperTitle) ?? false)
{
return;
}
await Task.Run(async() =>
{
await message.RemoveAllReactionsAsync();
if (reaction.Emote.Name == oneEmoji)
{
await message.ModifyAsync(msg => { msg.Content = AskTheOracleWithChance(90, OracleResources.AlmostCertain); msg.Embed = null; });
}
if (reaction.Emote.Name == twoEmoji)
{
await message.ModifyAsync(msg => { msg.Content = AskTheOracleWithChance(75, OracleResources.Likely); msg.Embed = null; });
}
if (reaction.Emote.Name == threeEmoji)
{
await message.ModifyAsync(msg => { msg.Content = AskTheOracleWithChance(50, OracleResources.FiftyFifty); msg.Embed = null; });
}
if (reaction.Emote.Name == fourEmoji)
{
await message.ModifyAsync(msg => { msg.Content = AskTheOracleWithChance(25, OracleResources.Unlikely); msg.Embed = null; });
}
if (reaction.Emote.Name == fiveEmoji)
{
await message.ModifyAsync(msg => { msg.Content = AskTheOracleWithChance(10, OracleResources.SmallChance); msg.Embed = null; });
}
});
return;
}
private async Task ExecuteGameInputAsync(IReactionsGame game, SocketReaction reaction, IUserMessage gameMessage)
{
var user = reaction.User.IsSpecified ? reaction.User.Value : client.GetUser(reaction.UserId);
var channel = gameMessage.Channel;
var guild = (channel as IGuildChannel)?.Guild;
await logger.Log(LogSeverity.Verbose, game.Name,
$"Input {PacManGame.GameInputs[reaction.Emote].ToString().Align(5)} " +
$"by {user.FullName()} in {channel.FullName()}");
game.Input(reaction.Emote, user.Id);
if (game.State != State.Active)
{
storage.DeleteGame(game);
if (game is PacManGame pmGame && pmGame.State != State.Cancelled && !pmGame.custom)
{
storage.AddScore(new ScoreEntry(pmGame.score, user.Id, pmGame.State, pmGame.Time,
user.NameandNum(), $"{guild?.Name}/{channel.Name}", DateTime.Now));
}
if (channel.BotCan(ChannelPermission.ManageMessages))
{
await gameMessage.RemoveAllReactionsAsync(Bot.DefaultOptions);
}
}
game.CancelRequests();
await gameMessage.ModifyAsync(game.UpdateMessage, game.RequestOptions);
}
public async Task<IUserMessage> SendMessageAsync(IMessageChannel channel, PaginatedMessage paginated)
{
IUserMessage message = await channel.SendMessageAsync("", embed: paginated.GetEmbed());
switch (paginated.Options.Style)
{
case DisplayStyle.Full:
await message.AddReactionAsync(paginated.Options.EmoteFirst);
await message.AddReactionAsync(paginated.Options.EmoteBack);
await message.AddReactionAsync(paginated.Options.EmoteNext);
await message.AddReactionAsync(paginated.Options.EmoteLast);
await message.AddReactionAsync(paginated.Options.EmoteStop);
break;
case DisplayStyle.Minimal:
await message.AddReactionAsync(paginated.Options.EmoteBack);
await message.AddReactionAsync(paginated.Options.EmoteNext);
await message.AddReactionAsync(paginated.Options.EmoteStop);
break;
case DisplayStyle.Selector:
await message.AddReactionAsync(paginated.Options.EmoteBack);
await message.AddReactionAsync(paginated.Options.EmoteStop);
await message.AddReactionAsync(paginated.Options.EmoteNext);
break;
}
Messages.Add(message.Id, paginated);
if (paginated.Options.Timeout != TimeSpan.Zero)
{
Task _ = Task.Delay(paginated.Options.Timeout).ContinueWith(async _t =>
{
if (!Messages.ContainsKey(message.Id))
{
return;
}
Console.WriteLine(paginated.Options.TimeoutAction.ToString());
if (paginated.Options.TimeoutAction == StopAction.DeleteMessage)
{
await message.DeleteAsync();
}
else if (paginated.Options.TimeoutAction == StopAction.ClearReactions)
{
await message.RemoveAllReactionsAsync();
}
Messages.Remove(message.Id);
});
}
return message;
}
public void DisplayTimeout(RestUserMessage m1, IUserMessage m2)
{
if (Timeout.HasValue)
{
_ = Task.Delay(Timeout.Value).ContinueWith(_ =>
{
Interactive.RemoveReactionCallback(m1);
m2.RemoveAllReactionsAsync();
});
}
}
public async Task WaitMess(ulong userId, IUserMessage socketMsg)
{
var globalAccount = _global.Client.GetUser(userId);
var account = _accounts.GetAccount(globalAccount);
var mainPage = new EmbedBuilder();
mainPage.WithAuthor(globalAccount);
mainPage.WithFooter("Preparation time...");
mainPage.WithColor(Color.DarkGreen);
mainPage.AddField("Game is being ready", $"**Please wait until you will see emoji** {new Emoji("❌")}");
await socketMsg.ModifyAsync(message => { message.Embed = mainPage.Build(); });
if (!(socketMsg.Channel is IDMChannel))
{
await socketMsg.RemoveAllReactionsAsync();
}
await socketMsg.AddReactionAsync(new Emoji("⬅"));
await socketMsg.AddReactionAsync(new Emoji("➡"));
await socketMsg.AddReactionAsync(new Emoji("📖"));
await socketMsg.AddReactionAsync(new Emoji("1⃣"));
await socketMsg.AddReactionAsync(new Emoji("2⃣"));
await socketMsg.AddReactionAsync(new Emoji("3⃣"));
await socketMsg.AddReactionAsync(new Emoji("4⃣"));
await socketMsg.AddReactionAsync(new Emoji("5⃣"));
await socketMsg.AddReactionAsync(new Emoji("6⃣"));
await socketMsg.AddReactionAsync(new Emoji("7⃣"));
await socketMsg.AddReactionAsync(new Emoji("8⃣"));
await socketMsg.AddReactionAsync(new Emoji("9⃣"));
await socketMsg.AddReactionAsync(new Emoji("🐙"));
await socketMsg.AddReactionAsync(new Emoji("❌"));
account.PlayingStatus = 2;
_accounts.SaveAccounts(userId);
await MainPage(userId, socketMsg);
}
public static async Task TeamInviteMenu(UserAccount user, IUserMessage message, IEmote emote, ContextIds idList)
{
switch (emote.Name.ToLower())
{
case "check":
if (user.GetTeam() == null)
{
if (user.InviteMessages.ContainsKey(message.Id))
{
var otherUser = UserHandler.GetUser(user.InviteMessages[message.Id]);
if (otherUser.GetTeam() != null)
{
user.InviteMessages.Remove(message.Id);
user.RemoveAllReactionMessages(10);
otherUser.GetTeam().AddMember(user);
await message.RemoveAllReactionsAsync();
//FOR FUTURE USE- When bot has no permissions, this can be used to remove bot-only reactions
//await message.RemoveReactionAsync(await MessageHandler.GetEmoji(736480922152730665), message.Author);
await message.ModifyAsync(m => { m.Embed = MonEmbedBuilder.TeamMenu(user); m.Content = ""; });
await MessageHandler.TeamMenuEmojis(message, user);
//Update the menu of the person who sent the invite
foreach (KeyValuePair <ulong, int> kvp in otherUser.ReactionMessages)
{
if (kvp.Value == 7)
{
IMessage teamMess = await message.Channel.GetMessageAsync(kvp.Key);
if (teamMess is IUserMessage)
{
IUserMessage userTeamMess = (IUserMessage)teamMess;
await userTeamMess.ModifyAsync(m => { m.Embed = MonEmbedBuilder.TeamMenu(otherUser); m.Content = ""; });
}
}
}
}
}
}
break;
case "redx":
user.InviteMessages.Remove(message.Id);
user.RemoveAllReactionMessages(10);
await message.ModifyAsync(m => { m.Content = "Invite Declined."; });
break;
default:
break;
}
}
private async Task ResetReactionsIfNecessary(Workshop currentWorkshop, Emoji thumbsUpEmote, Workshop dbWorkshop, IUserMessage message)
{
if (dbWorkshop == null)
{
return;
}
if (!WorkshopHelpers.TimeHasChanged(dbWorkshop, currentWorkshop))
{
return;
}
var hadOneUser = false;
var reactedUsers = message.GetReactionUsersAsync(thumbsUpEmote, 1000)
.SelectMany(x => x.ToAsyncEnumerable())
.Where(x => !x.IsBot && x.Id != _discordClient.CurrentUser.Id);
await foreach (var reactedUser in reactedUsers)
{
hadOneUser = true;
// Notify user that time has changed
var affectedTimes = new string[]
{
!WorkshopHelpers.BeginTimeChanged(dbWorkshop, currentWorkshop) ? string.Empty : "Startzeit",
!WorkshopHelpers.EndTimeChanged(dbWorkshop, currentWorkshop) ? string.Empty : "Endzeit"
}.Where(x => !string.IsNullOrEmpty(x));
var affectedTimeString = string.Join(" und ", affectedTimes);
try
{
await reactedUser.SendMessageAsync
(
$"Die {affectedTimeString} vom Workshop **{currentWorkshop.title}** wurde geändert. \n" +
$"Er beginnt um **{currentWorkshop.begintime}** und endet um {currentWorkshop.endtime}.:alarm_clock:\n" +
$"Deshalb wurde deine Benachrichtigung deaktiviert. Bitte reagiere erneut mit \U0001F44D auf die Nachricht am Server, damit du rechtzeitig erinnert wirst!"
);
}
catch (Exception)
{
//Ignore
}
}
if (hadOneUser)
{
await message.RemoveAllReactionsAsync();
await message.AddReactionAsync(thumbsUpEmote);
}
}
private async Task CreatureReactionHandler(IUserMessage message, ISocketMessageChannel channel, SocketReaction reaction, IUser user)
{
var CreatureHelperEmbed = message.Embeds.FirstOrDefault(embed => embed?.Title?.Contains(CreatureResources.CreatureHelper) ?? false);
if (CreatureHelperEmbed != null)
{
CreatureEnvironment environment = StarforgedUtilites.CreatureEnvironmentFromEmote(reaction.Emote.Name);
if (reaction.Emote.Name == randomEmoji.Name)
{
string lookupValue = Services.GetRequiredService <OracleService>().RandomRow("Creature Environment").Description;
environment = StarforgedUtilites.GetAnyEnvironment(lookupValue);
}
if (environment == CreatureEnvironment.None)
{
return;
}
var newCreature = Creature.GenerateCreature(Services, channel.Id, environment);
Task.WaitAll(message.RemoveAllReactionsAsync());
await message.ModifyAsync(msg =>
{
msg.Content = string.Empty;
msg.Embed = newCreature.GetEmbedBuilder().Build();
}).ConfigureAwait(false);
await message.AddReactionAsync(revealAspectEmoji).ConfigureAwait(false);
return;
}
var creatureEmbed = message.Embeds.FirstOrDefault(embed => embed?.Title?.Contains(CreatureResources.CreatureTitle) ?? false);
if (creatureEmbed == null)
{
return;
}
var creature = Creature.FromEmbed(creatureEmbed, Services, channel.Id);
if (reaction.Emote.Name == revealAspectEmoji.Name)
{
creature.RevealedAspectsToShow++;
}
await message.ModifyAsync(msg => msg.Embed = creature.GetEmbedBuilder().Build()).ConfigureAwait(false);
await message.RemoveReactionAsync(reaction.Emote, user).ConfigureAwait(false);
return;
}
private async Task ShipReactionHandler(IUserMessage message, ISocketMessageChannel channel, SocketReaction reaction, IUser user)
{
var starshipHelperEmbed = message.Embeds.FirstOrDefault(embed => embed?.Title?.Contains(StarShipResources.StarshipHelperTitle) ?? false);
if (starshipHelperEmbed != null)
{
var region = StarforgedUtilites.SpaceRegionFromEmote(reaction.Emote.Name);
if (region == SpaceRegion.None)
{
return;
}
string name = starshipHelperEmbed.Fields.FirstOrDefault(fld => fld.Name == StarShipResources.StarshipName).Value ?? string.Empty;
Starship newShip = Starship.GenerateShip(Services, region, name);
Task.WaitAll(message.RemoveAllReactionsAsync());
await message.ModifyAsync(msg =>
{
msg.Content = string.Empty;
msg.Embed = newShip.GetEmbedBuilder().Build();
}).ConfigureAwait(false);
await message.AddReactionAsync(missionEmoji).ConfigureAwait(false);
return;
}
var shipEmbed = message.Embeds.FirstOrDefault(embed => embed?.Description?.Contains(StarShipResources.Starship, StringComparison.OrdinalIgnoreCase) ?? false);
if (shipEmbed == null)
{
return;
}
Starship ship = Starship.FromEmbed(Services, shipEmbed);
if (reaction.Emote.Name == missionEmoji.Name)
{
ship.MissionRevealed = true;
await message.RemoveReactionAsync(reaction.Emote, message.Author).ConfigureAwait(false);
}
await message.ModifyAsync(msg => msg.Embed = ship.GetEmbedBuilder().Build()).ConfigureAwait(false);
await message.RemoveReactionAsync(reaction.Emote, user).ConfigureAwait(false);
return;
}
private async Task SettlementReactionHandler(IUserMessage message, ISocketMessageChannel channel, SocketReaction reaction, IUser user)
{
var settlementHelperEmbed = message.Embeds.FirstOrDefault(embed => embed?.Title?.Contains(SettlementResources.SettlementHelper) ?? false);
if (settlementHelperEmbed != null)
{
var region = StarforgedUtilites.SpaceRegionFromEmote(reaction.Emote.Name);
if (region == SpaceRegion.None)
{
return;
}
string name = settlementHelperEmbed.Fields.FirstOrDefault(fld => fld.Name == SettlementResources.SettlementName).Value ?? string.Empty;
var newSettlement = Settlement.GenerateSettlement(Services, region, name);
Task.WaitAll(message.RemoveAllReactionsAsync());
await message.ModifyAsync(msg =>
{
msg.Content = string.Empty;
msg.Embed = newSettlement.GetEmbedBuilder().Build();
}).ConfigureAwait(false);
await message.AddReactionAsync(projectEmoji).ConfigureAwait(false);
return;
}
var settlmentEmbed = message.Embeds.FirstOrDefault(embed => embed?.Description?.Contains(SettlementResources.Settlement) ?? false);
if (settlmentEmbed == null)
{
return;
}
var settlement = new Settlement(Services).FromEmbed(settlmentEmbed);
if (reaction.Emote.Name == projectEmoji.Name)
{
settlement.ProjectsRevealed++;
}
await message.ModifyAsync(msg => msg.Embed = settlement.GetEmbedBuilder().Build()).ConfigureAwait(false);
await message.RemoveReactionAsync(reaction.Emote, user).ConfigureAwait(false);
return;
}
private async Task RunClipReactions(IUserMessage message, string vid, [NotNull] Task playingClip)
{
//Setup reaction buttons
await Task.Run(async() => await AddYoutubeReactions(message, vid));
//Wait for the clip to finish playing
await playingClip;
//After a short time remove the reactions
Console.WriteLine("Track complete, starting timeout...");
await Task.Delay(ReactionTimeout).ContinueWith(async _ => {
Console.WriteLine("Timeout complete!");
Interactive.RemoveReactionCallback(message);
await message.RemoveAllReactionsAsync();
});
}
protected override async Task CloseMessageAsync(IUserMessage message, InteractivityResult <TValue> result)
{
//the remove all reactions endpoint requires the user to have the manage messages permission
//the user wont have this in a DM channel and calling this will throw HttpExceptions
if (message.Channel is not IDMChannel)
{
await message.RemoveAllReactionsAsync();
}
if (result.IsCancelled && CancelledPage != null)
{
await message.ModifyAsync(x => { x.Content = CancelledPage.Text; x.Embed = CancelledPage.Embed; });
}
if (result.IsTimeouted && TimeoutedPage != null)
{
await message.ModifyAsync(x => { x.Content = TimeoutedPage.Text; x.Embed = TimeoutedPage.Embed; });
}
}
private async Task ExecuteCommandAsync(string command, SocketCommandContext context)
{
switch (command)
{
case "ls":
await StartList(context);
break;
case "ende":
await list.DeleteAsync();
_offline = new List <string>();
listOpen = false;
break;
case "v":
if (listOpen)
{
foreach (Student item in _students)
{
item._veryfied = false;
}
await list.RemoveAllReactionsAsync();
await list.AddReactionAsync(new Emoji("✅"));
await UpdateList();
}
break;
case "hilfe":
await context.Channel.SendMessageAsync("", false, new EmbedBuilder().WithTitle("Kommandos").AddField("Generell", "+ls -> Liste Starten.\n+v -> neue Verifizierung.\n+ende -> liste Beenden.\n+hilfe -> Hilfe anzeigen.").Build());
break;
default:
break;
}
}
public async Task DisplayAsync()
{
var embed = BuildEmbed();
var message = await Context.Channel.SendMessageAsync(_pager.Content, embed : embed).ConfigureAwait(false);
Message = message;
Interactive.AddReactionCallback(message, this);
// Reactions take a while to add, don't wait for them
_ = Task.Run(async() =>
{
await message.AddReactionAsync(options.First);
await message.AddReactionAsync(options.Back);
await message.AddReactionAsync(options.Next);
await message.AddReactionAsync(options.Last);
var manageMessages = (Context.Channel is IGuildChannel guildChannel)
? (Context.User as IGuildUser).GetPermissions(guildChannel).ManageMessages
: false;
if (options.JumpDisplayOptions == JumpDisplayOptions.Always ||
(options.JumpDisplayOptions == JumpDisplayOptions.WithManageMessages && manageMessages))
{
await message.AddReactionAsync(options.Jump);
}
await message.AddReactionAsync(options.Stop);
if (options.DisplayInformationIcon)
{
await message.AddReactionAsync(options.Info);
}
});
// TODO: (Next major version) timeouts need to be handled at the service-level!
if (Timeout.HasValue && Timeout.Value != null)
{
_ = Task.Delay(Timeout.Value).ContinueWith(_ =>
{
Interactive.RemoveReactionCallback(message);
_ = Message.RemoveAllReactionsAsync();
});
}
}
/// <summary>
/// Removes the message from the handler.
///
/// Also removes all reactions.
/// </summary>
/// <param name="message">The message to remove from the handler.</param>
/// <returns></returns>
public async Task ClearHandler(IUserMessage message)
{
try
{
if (emojiRemovedFunctions.Any(x => x.Key.Id.Equals(message.Id)))
{
emojiRemovedFunctions.Remove(emojiRemovedFunctions.First(x => x.Key.Id.Equals(message.Id)).Key);
}
if (emojiAddedFunctions.Any(x => x.Key.Id.Equals(message.Id)))
{
emojiAddedFunctions.Remove(emojiAddedFunctions.First(x => x.Key.Id.Equals(message.Id)).Key);
}
await message.RemoveAllReactionsAsync();
}
catch (Exception e)
{
await Program.MopsLog(new LogMessage(LogSeverity.Error, "", $"Tried to delete message {message.Id} but it did not exist.", e));
}
}
private async Task SetStateAsync(IUserMessage message, State state)
{
Owners[message.Id].State = state;
await message.RemoveAllReactionsAsync().ConfigureAwait(false);
switch (state)
{
case State.Select:
await message.AddReactionAsync(new Emoji("🛡")).ConfigureAwait(false);
await message.AddReactionAsync(new Emoji("⚡")).ConfigureAwait(false);
await message.AddReactionAsync(new Emoji("🗼")).ConfigureAwait(false);
await message.AddReactionAsync(new Emoji("❌")).ConfigureAwait(false);
await message.AddReactionAsync(new Emoji("✅")).ConfigureAwait(false);
break;
}
}
