public static async Task PerformAsync(ShardedCommandContext context, DataBase db) { try { var guild = FindOrCreateGuild.Perform(context.Guild, db); // toList to force enumeration before we shuffle identifier var bannedUsers = context.Guild.Users.Where(x => PrefixHelper.UserBlocked(x.Id, guild)).ToList(); guild.UserIdentifierSeed = new Random().Next(int.MinValue, int.MaxValue); var items = bannedUsers.Select(x => PrefixHelper.GetIdentifierString(x.Id, guild)).Select(x => new BannedIdentifier { Identifier = x }); db.RemoveRange(guild.BannedIdentifiers); items.Select((x) => { guild.BannedIdentifiers.Add(x); return(true); }).ToList(); db.SaveChanges(); await context.Channel.SendMessageAsync(text : "User identifiers have been randomized."); } catch (Exception ex) { Console.WriteLine("error rotating"); Console.WriteLine(ex.ToString()); } }
public static async Task PerformAsync(ShardedCommandContext context, DataBase db) { var guild = FindOrCreateGuild.Perform(context.Guild, db); if (EnsureActiveSubscription.Perform(guild, db)) { var service = new SubscriptionService(); var subscription = service.Get(guild.SubscriptionId); var amount = subscription.Plan.Amount; var date = subscription.CurrentPeriodEnd; var message = $"Your current subscription will renew {date.Value.ToLongDateString()}.\n" + $"To cancel your subscription, use the `!volt cancel` command."; await context.Channel.SendMessageAsync(text : message); } else { var size = context.Guild.MemberCount <= 200 ? "s" : "l"; var url = $"https://nminchow.github.io/VoltaireWeb/upgrade?serverId={context.Guild.Id.ToString()}&type={size}"; var view = Views.Info.Pro.Response(url, guild, db); try { await context.Channel.SendMessageAsync(view.Item1, embed : view.Item2); } catch (Discord.Net.HttpException e) { await context.Channel.SendMessageAsync(text : $"Use this URL to upgrade to Volatire Pro: {url}"); } } }
/// <summary> /// /// </summary> /// <param name="rawMessage"></param> /// <returns></returns> public async Task MessageReceivedAsync(SocketMessage rawMessage) { // Ignore system messages, or messages from other bots if (!(rawMessage is SocketUserMessage message)) { return; } if (message.Source != MessageSource.User) { return; } // Perform a basic check to verify the incoming message is a command invocation var argPos = 0; if (!message.HasCharPrefix('!', ref argPos) && (!message.HasMentionPrefix(this.discord.CurrentUser, ref argPos))) { return; } var context = new ShardedCommandContext(this.discord, message); await this.commands.ExecuteAsync(context, argPos, this.services); }
public async Task <IUserMessage> SendPaginatedMessageAsync(ShardedCommandContext context, PaginatedMessage pager, ICriterion <SocketReaction> criterion = null) { var callback = new PaginatedMessageCallback(this, context, pager, criterion); await callback.DisplayAsync().ConfigureAwait(false); return(callback.Message); }
public async Task <Embed> NowPlayingAsync(ShardedCommandContext context) { if (!_lavaNode.TryGetPlayer(context.Guild, out var player)) { return(EmbedHandler.CreateEmbed(context, "Music", $"{Global.ENo} | I'm not connected to a voice channel.", EmbedHandler.EmbedMessageType.Error)); } if (player.PlayerState != PlayerState.Playing) { return(EmbedHandler.CreateEmbed(context, "Music", $"{Global.ENo} | There's nothing playing at the moment", EmbedHandler.EmbedMessageType.Error)); } var track = player.Track; var artwork = await track.FetchArtworkAsync(); var embed = new EmbedBuilder { Title = $"{track.Author} - {track.Title}", ThumbnailUrl = artwork, Description = GetSong(player), Url = track.Url, Color = Global.NayuColor, }; embed.WithFooter($"Id: {track.Id}"); return(embed.Build()); }
private Task ExecuteAsync(SocketUserMessage message, int argPos) { // A new kind of command context, ShardedCommandContext can be utilized with the commands framework var context = new ShardedCommandContext(_discord, message); return(_commands.ExecuteAsync(context, argPos, _services)); }
public virtual async Task <(GameResult, string)> PickOneAsync(Database db, ShardedCommandContext context, GameResult game, SocketGuildUser[] users, TeamCaptain cap1, TeamCaptain cap2) { var uc = users.Count(); var teamCaptain = game.Picks % 2 == 0 ? cap1 : cap2; var offTeamCaptain = game.Picks % 2 == 0 ? cap2 : cap1; if (context.User.Id != teamCaptain.UserId) { await context.Channel.SendMessageAsync("", false, $"{context.User.Mention} - It is currently the other captains turn to pick.".QuickEmbed(Color.Red)); return(null, null); } if (uc == 0) { await context.Channel.SendMessageAsync("", false, $"{context.User.Mention} - You must specify a player to pick.".QuickEmbed(Color.Red)); return(null, null); } else if (uc != 1) { await context.Channel.SendMessageAsync("", false, $"{context.User.Mention} - You can only specify one player for this pick.".QuickEmbed(Color.Red)); return(null, null); } db.TeamPlayers.Add(GetPlayer(game, users[0], game.Picks % 2 == 0 ? 1 : 2)); var pickResponse = $"{MentionUtils.MentionUser(offTeamCaptain.UserId)} can select **1** player for the next pick."; return(game, pickResponse); }
private async Task HandleCommandAsync(SocketMessage msg) { var argPos = 0; if (!(msg is SocketUserMessage message)) { return; } await _balanceService.MessageCoin(message.Author.Id); var guildChannel = (SocketGuildChannel)message.Channel; var r = await _databaseService.LoadRecordsByGuildId(guildChannel.Guild.Id); if (message.HasStringPrefix(r.Prefix, ref argPos)) { var context = new ShardedCommandContext(_client, message); var result = await _commandService.ExecuteAsync(context, argPos, _services); if (!result.IsSuccess && result.Error != CommandError.UnknownCommand) { await context.Channel.SendMessageAsync(result.ErrorReason); } } }
internal static bool UserHasRole(ShardedCommandContext ctx, ulong roleId) { var targetRole = ctx.Guild.Roles.FirstOrDefault(r => r.Id == roleId); var guildUser = ctx.User as SocketGuildUser; return(guildUser.Roles.Contains(targetRole)); }
public static async Task Reset(ShardedCommandContext context, Core.Entities.Chomusuke chom1, Core.Entities.Chomusuke chom2) { var config = GlobalUserAccounts.GetUserAccount(context.User); var player2 = context.Guild.GetUser(config.OpponentId); var configg = GlobalUserAccounts.GetUserAccount(player2); config.Fighting = false; configg.Fighting = false; chom1.Health = chom1.HealthCapacity; chom2.Health = chom2.HealthCapacity; config.OpponentId = 0; configg.OpponentId = 0; config.OpponentName = null; configg.OpponentName = null; config.WhosTurn = null; config.WhoWaits = null; config.PlaceHolder = null; configg.WhosTurn = null; configg.WhoWaits = null; chom1.Effects?.Clear(); chom2.Effects?.Clear(); chom1.PotionEffects?.Clear(); chom2.PotionEffects?.Clear(); await ActiveChomusuke.ConvertActiveVariable(context.User.Id, config.OpponentId, chom1, chom2); GlobalUserAccounts.SaveAccounts(config.Id, configg.Id); }
public static AttackResult DeflectAttack(ShardedCommandContext context) { var config = GlobalUserAccounts.GetUserAccount(context.User); var chom = ActiveChomusuke.GetOneActiveChomusuke(config.Id); string response; bool success = false; int dmg = 0; if (chom.Effects.Contains(Effect.Blocking)) { response = "You cannot block while already in blocking formation! Try again!"; return(new AttackResult { Success = success, Response = response, Damage = dmg }); } if (chom.Effects.Contains(Effect.Deflecting)) { response = "You are already in deflecting formation! Try again!"; return(new AttackResult { Success = success, Response = response, Damage = dmg }); } chom.Effects.Add(Effect.Deflecting); GlobalUserAccounts.SaveAccounts(config.Id); response = $":shield: **|** **{config.OpponentName}**, You are now in deflecting formation!\n\n**{config.OpponentName}**'s shield will deflect 50% of the damage from the next attack"; success = true; return(new AttackResult { Success = success, Response = response, Damage = dmg }); }
public static async Task PerformAsync(ShardedCommandContext context, string identifier, DataBase db) { if (!BanIdentifier.ValidIdentifier(identifier)) { await context.Channel.SendMessageAsync("Please use the 4 digit number following the identifier to unban users."); return; } var guild = FindOrCreateGuild.Perform(context.Guild, db); var identifiers = guild.BannedIdentifiers.Where(x => x.Identifier == identifier); if (identifiers.Count() == 0) { await context.Channel.SendMessageAsync("That user is not currently banned."); return; } db.BannedIdentifiers.RemoveRange(identifiers.ToList()); db.SaveChanges(); await context.Channel.SendMessageAsync(text : $"{identifier} is now unbanned"); }
public static async Task Burned(ShardedCommandContext context) { var config = GlobalUserAccounts.GetUserAccount(context.User); var chom = ActiveChomusuke.GetOneActiveChomusuke(config.Id); var dmg = (uint)Global.Rng.Next(2, 5); if (!chom.Effects.Contains(Effect.Burned)) { return; } var rng = Global.Rng.Next(1, 5); if (rng == 4) { chom.Effects.Remove(Effect.Burned); GlobalUserAccounts.SaveAccounts(config.Id); await SendMessage(context, null, $"{chom.Name} stopped burning!"); return; } chom.Health -= dmg; GlobalUserAccounts.SaveAccounts(config.Id); await SendMessage(context, null, $"{chom.Name} took {dmg} from being burned!"); }
public static PotionResult ExecutePotion(ShardedCommandContext context, string potion, ulong user, ulong target) { var config = GlobalUserAccounts.GetUserAccount(user); var choms = ActiveChomusuke.GetActiveChomusuke(user, config.OpponentId); var chom1 = choms.Item1; var chom2 = choms.Item2; var result = new PotionResult(); switch (potion) { case "Strength Potion": result = Potions.StrengthPotion(context, chom1, chom2, target); break; case "Debuff Potion": result = Potions.DebuffPotion(context, chom1, chom2, target); break; case "Speed Potion": result = Potions.SpeedPotion(context, chom1, chom2, target); break; case "Equalizer Potion": result = Potions.EqualizerPotion(context, chom1, chom2, target); break; } return(result); }
public static async Task PerformAsync(ShardedCommandContext context, string identifier, DataBase db) { if (!ValidIdentifier(identifier)) { await context.Channel.SendMessageAsync("Please use the 4 digit number following the identifier to ban users."); return; } var guild = FindOrCreateGuild.Perform(context.Guild, db); if (!EnsureActiveSubscription.Perform(guild, db)) { await context.Channel.SendMessageAsync("You need an active Voltaire Pro subscription to ban users. To get started, use `!volt pro`"); return; } if (guild.BannedIdentifiers.Any(x => x.Identifier == identifier)) { await context.Channel.SendMessageAsync("That identifier is already banned!"); return; } guild.BannedIdentifiers.Add(new BannedIdentifier { Identifier = identifier }); db.SaveChanges(); await context.Channel.SendMessageAsync(text : $"{identifier} is now banned"); }
public static EmbedBuilder CreateEmbed(ShardedCommandContext ctx, string title, string desc) { var thumbnailurl = ctx.User.GetAvatarUrl(); var boturl = Global.Client.CurrentUser.GetAvatarUrl(); var auth = new EmbedAuthorBuilder() { IconUrl = thumbnailurl, Name = ctx.User.Username }; var footer = new EmbedFooterBuilder() { IconUrl = boturl, Text = "Nayu | n!help" }; var embed = new EmbedBuilder() { Author = auth, Footer = footer, Color = Global.NayuColor, Title = title, Description = desc, }; return(embed); }
public static AttackResult MeditateAttack(ShardedCommandContext context, Core.Entities.Chomusuke chom) { var config = GlobalUserAccounts.GetUserAccount(context.User); string response; bool success = false; var dmg = 0; if (chom.Effects.Contains(Effect.Meditating)) { response = $"{chom.Name} has already meditated! Try Again!"; } else if (chom.Effects.Contains(Effect.Blocking)) { response = $"{chom.Name} cannot meditate while in blocking formation! Try Again!"; } else if (chom.Effects.Contains(Effect.Deflecting)) { response = $"{chom.Name} cannot meditate while in deflecting formation! Try Again!"; } else { response = $":shield: **|** **{config.OpponentName}**, {chom.Name} just meditated! \n\n**{config.OpponentName}**'s next attack will deal 30% more damage"; chom.Effects.Add(Effect.Meditating); GlobalUserAccounts.SaveAccounts(config.Id); success = true; } return(new AttackResult { Success = success, Response = response, Damage = dmg }); }
public async Task HandleCommandAsync(SocketMessage message) { if (message is not SocketUserMessage possibleCmd || possibleCmd.Author.IsBot || string.IsNullOrEmpty(possibleCmd.Content)) { return; } var prefix = "y!"; if (possibleCmd.Channel is SocketTextChannel textChannel) { var id = textChannel.Guild.Id; var guildConfig = await _guildConfigDbService.GetGuildConfigAsync(id); prefix = guildConfig.Prefix; } var argPos = 0; if ((possibleCmd.HasStringPrefix(prefix, ref argPos) || possibleCmd.HasMentionPrefix(_client.CurrentUser, ref argPos)) && possibleCmd.Content.Trim() != prefix) { var context = new ShardedCommandContext(_client, possibleCmd); var user = possibleCmd.Author; switch (possibleCmd.Channel) { case SocketDMChannel: _logger.Info("{Username:l}#{Discriminator:l} in DM's", user.Username, user.Discriminator); break; case SocketTextChannel txtChannel: _logger.Info("{Username:l}#{Discriminator:l} from {GuildName:l}/{ChannelName:l}", user.Username, user.Discriminator, txtChannel.Guild.Name, txtChannel.Name); break; } _logger.Info(possibleCmd.Content); var result = await _commandService.ExecuteAsync(context, argPos, _serviceProvider); if (!result.IsSuccess) { if (result.ErrorReason.Contains("unknown command", StringComparison.OrdinalIgnoreCase)) { return; } if (result.ErrorReason.Contains("you are currently in timeout", StringComparison.OrdinalIgnoreCase)) { await context.Channel.SendMessageAsync("Please wait 5 seconds between each type of paginator command!"); } //await context.Channel.SendMessageAsync("https://goo.gl/JieFJM"); _logger.Error(result.ErrorReason); } } }
private async Task MessageReceived(SocketMessage message) { SocketUserMessage Message = message as SocketUserMessage; SocketCommandContext Context = new ShardedCommandContext(_client, Message); if (Context.User.IsBot) { return; } int argpos = 0; var user = await Users.GetOrAddValue((long)Context.User.Id); await Users.SaveAsync(user); if (!Message.HasStringPrefix(user.Prefix, ref argpos) && !Message.HasMentionPrefix(Context.Client.CurrentUser, ref argpos)) { return; } if (_userTimeouts.AddOrUpdate(Context.User.Id, 1, (ulong id, int i) => { return(i + 1); }) == 5) { _userTimeouts[Context.User.Id]--; return; } var result = await _commandService.ExecuteAsync(Context, argpos, _services); if (!result.IsSuccess) { _ = Context.Channel.SendMessageAsync($"{Context.User.Mention} Error: `{result.ErrorReason}`"); } }
private Task OnMessageReceivedAsync(SocketMessage s) { _ = Task.Run(async() => { if (!(s is SocketUserMessage msg)) { return; } if (!(s.Channel is SocketGuildChannel)) { return; } int argPos = 0; var context = new ShardedCommandContext(_discord, msg); if (msg.HasMentionPrefix(_discord.CurrentUser, ref argPos)) { if (!(context.User as SocketGuildUser).GuildPermissions.Administrator) { if (IsRatelimited(context.User.Id)) { return; } } using (context.Channel.EnterTypingState()) { await ExecuteAsync(context, _provider, context.Message.Content.Substring(argPos)); } } }); return(Task.CompletedTask); }
public async Task <SocketMessage> NextMessageAsync(ShardedCommandContext context, ICriterion <SocketMessage> criterion, TimeSpan?timeout = null) { timeout = timeout ?? _defaultTimeout; var eventTrigger = new TaskCompletionSource <SocketMessage>(); async Task Handler(SocketMessage message) { var result = await criterion.JudgeAsync(context, message).ConfigureAwait(false); if (result) { eventTrigger.SetResult(message); } } context.Client.MessageReceived += Handler; var trigger = eventTrigger.Task; var delay = Task.Delay(timeout.Value); var task = await Task.WhenAny(trigger, delay).ConfigureAwait(false); context.Client.MessageReceived -= Handler; if (task == trigger) { return(await trigger.ConfigureAwait(false)); } else { return(null); } }
public static async Task PerformAsync(ShardedCommandContext context, string guildName, string channelName, string message, bool replyable, DataBase db) { var unfilteredList = Send.GuildList(context); var candidateGuilds = unfilteredList.Where(x => x.Id.ToString() == guildName || x.Name.ToLower().Contains(guildName.ToLower())); switch (candidateGuilds.Count()) { case 0: await Send.SendErrorWithDeleteReaction(context, "No servers with the specified name could be found. The servers must have Voltaire installed and you must be a member of the server."); break; case 1: await LookupAndSendAsync(candidateGuilds.First(), context, channelName, message, replyable, db); break; default: // check for exact match var exactNameMatch = candidateGuilds.First(x => x.Id.ToString() == guildName || x.Name.ToLower() == guildName.ToLower()); if (exactNameMatch != null) { await LookupAndSendAsync(exactNameMatch, context, channelName, message, replyable, db); return; } await Send.SendErrorWithDeleteReaction(context, "More than one server with the spcified name was found. Please use a more specific server name."); break; } }
private async Task HandleCommandAsync(SocketMessage message) { var msg = message as SocketUserMessage; if (msg == null) { return; } var context = new ShardedCommandContext(_client, msg); int argPos = 0; if (msg.Author.IsBot) { return; } if (msg.HasStringPrefix(_botPrefix, ref argPos)) { var result = await _command.ExecuteAsync(context, argPos, _services); if (!result.IsSuccess && result.Error != CommandError.UnknownCommand) { Console.WriteLine(result.ErrorReason); return; } } }
private async Task OnMessageReceivedAsync(SocketMessage s) { var msg = s as SocketUserMessage; // Ensure the message is from a user/bot if (msg == null) { return; } if (msg.Author.Id == this._discord.CurrentUser.Id) { return; // Ignore self when checking commands } if (msg.Author.IsBot) { return; // Ignore bots } var context = new ShardedCommandContext(this._discord, msg); // Create the command context var argPos = 0; // Check if the message has a valid command prefix var customPrefix = this._prefixService.GetPrefix(context.Guild?.Id); if (msg.HasStringPrefix(ConfigData.Data.CommandPrefix, ref argPos) && customPrefix == null || msg.HasMentionPrefix(this._discord.CurrentUser, ref argPos)) { await ExecuteCommand(msg, context, argPos); } else if (msg.HasStringPrefix(customPrefix, ref argPos, StringComparison.CurrentCultureIgnoreCase)) { await ExecuteCommand(msg, context, argPos, customPrefix); } }
private static async Task FaqProccesser(SocketMessage socketMessage) { var argPos = 0; var message = socketMessage as SocketUserMessage; if (message == null) { return; } if (!message.HasStringPrefix("?fa", ref argPos)) { return; } var context = new ShardedCommandContext(_client, message); if (context.IsPrivate) { return; } if (!context.Channel.CheckChannelPermission(ChannelPermission.SendMessages, context.Guild.CurrentUser)) { return; } var result = await _commandService.ExecuteAsync(context, argPos, _provider); if (!result.IsSuccess) { Logger.Warn(result); } }
private async Task <bool> CommandAsync(SocketUserMessage message) { var context = new ShardedCommandContext(client, message); string prefix = storage.GetPrefix(context.Guild); int commandPosition = 0; if (message.HasMentionPrefix(client.CurrentUser, ref commandPosition) || message.HasStringPrefix($"{prefix} ", ref commandPosition) || message.HasStringPrefix(prefix, ref commandPosition) || context.Channel is IDMChannel || storage.NoPrefixChannel(context.Channel.Id)) { var result = await commands.ExecuteAsync(context, commandPosition, provider); if (result.IsSuccess) { return(true); } else if (!result.ErrorReason.Contains("Unknown command")) { await logger.Log(LogSeverity.Verbose, LogSource.Command, $"\"{message}\" by {message.Author.FullName()} in {context.Channel.FullName()} " + $"couldn't be executed. {result.ErrorReason}"); string reply = CommandErrorReply(result.ErrorReason, context.Guild); if (reply != null && context.BotCan(ChannelPermission.SendMessages)) { await context.Channel.SendMessageAsync(reply, options : Bot.DefaultOptions); } return(true); } } return(false); }
private async Task FaqProccesser(SocketMessage socketMessage) { var argPos = 0; var message = socketMessage as SocketUserMessage; if (message == null) { return; } if (!message.HasStringPrefix(_config["Prefixes:Faq"], ref argPos, StringComparison.OrdinalIgnoreCase)) { return; } var context = new ShardedCommandContext(_client, message); if (context.IsPrivate) { return; } if (!context.Channel.CheckChannelPermission(ChannelPermission.SendMessages, context.Guild.CurrentUser)) { return; } var result = await _commandService.ExecuteAsync(context, argPos, _provider); if (!result.IsSuccess) { if (message.HasStringPrefix(_config["Prefixes:Main"], ref argPos, StringComparison.OrdinalIgnoreCase)) { return; } _logger.LogWarning(new EventId(515), result.ErrorReason); } }
public async Task MessageReceivedAsync(SocketMessage rawMessage) { // Ignore system messages, or messages from other bots if (!(rawMessage is SocketUserMessage message)) { return; } if (message.Source != MessageSource.User) { return; } // This value holds the offset where the prefix ends var argPos = 0; if (!message.HasMentionPrefix(_discord.CurrentUser, ref argPos)) { if (message.Content.ToUpper().StartsWith("BG") || message.Content.ToUpper().StartsWith("JB")) { argPos = 2; } else { return; } } // A new kind of command context, ShardedCommandContext can be utilized with the commands framework var context = new ShardedCommandContext(_discord, message); await _commands.ExecuteAsync(context, argPos, _services); }
/// <summary> /// Checks if the message contains a prefix. /// </summary> /// <param name="msg">The socket user message.</param> private async Task CheckForPrefixAsync(SocketUserMessage msg) { // If the user is a bot, return. if (msg.Author.IsBot) { return; } // Create the shared command context. var context = new ShardedCommandContext(_client, msg); var argPos = 0; // Check if the message has a valid default command prefix. if (context.Message.HasStringPrefix(Constants.Prefix, ref argPos, StringComparison.CurrentCultureIgnoreCase) || context.Message.HasMentionPrefix(_client.CurrentUser, ref argPos)) { await HandleCommandAsync(context, argPos).ConfigureAwait(false); } // Check if the message has a valid custom command prefix. var customPrefix = _prefixService.GetPrefix(context.Guild.Id); if (customPrefix == null) { return; } if (context.Message.HasStringPrefix(customPrefix, ref argPos, StringComparison.CurrentCultureIgnoreCase)) { await HandleCommandAsync(context, argPos).ConfigureAwait(false); } }
public static async Task SendMessageAndCatchError(Func <Task> send, ShardedCommandContext context) { try { await send(); } catch (Discord.Net.HttpException e) { switch (e.DiscordCode) { case 50007: await context.Channel.SendMessageAsync("Voltaire has been blocked by this user."); break; case 50013: case 50001: await context.Channel.SendMessageAsync("Voltaire doesn't have the " + "permissions required to send this message. Ensure Voltaire can access the channel you are tyring to send to, and that it has " + " \"Embed Links\" and \"Use External Emojis\" permission."); break; } throw e; } }