Esempio n. 1
0
 private async Task SlashCommandErrorHandler(SlashCommandsExtension extension, SlashCommandErrorEventArgs args)
 {
     try
     {
         if (args.Exception is SlashExecutionChecksFailedException slex)
         {
             foreach (var check in slex.FailedChecks)
             {
                 if (check is RequireChannelsAttribute requireChannelAttribute)
                 {
                     await args.Context.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder().AsEphemeral(true).WithContent(Language.Current.DiscordCommandNotAvailableInChannel));
                 }
                 else if (check is RequireRolesAttribute requireRoleAttribute)
                 {
                     await args.Context.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder().AsEphemeral(true).WithContent(Language.Current.DiscordCommandMissingRoles));
                 }
                 else
                 {
                     await args.Context.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder().AsEphemeral(true).WithContent(Language.Current.DiscordCommandUnknownPrecondition));
                 }
             }
         }
     }
     catch (System.Exception ex)
     {
         _logger.LogError(ex, "Error while handling interaction error: " + ex.Message);
     }
 }
Esempio n. 2
0
 public WikiFeature(DiscordClient dClient, JobManager jobManager, WikiJob wikiJob)
 {
     this.cNext      = dClient.GetCommandsNext();
     this.jobManager = jobManager;
     this.wikiJob    = wikiJob;
     this.slash      = dClient.GetSlashCommands();
 }
 public static Task RegisterErrorHandler(ServiceProvider sp, Logger log, SlashCommandsExtension e)
 {
     ServiceProvider        = sp;
     Log                    = log;
     e.SlashCommandErrored += Slash_SlashCommandErrored;
     return(Task.CompletedTask);
 }
Esempio n. 4
0
        private async Task OnSlashCommandExecuted(SlashCommandsExtension sender, DSharpPlus.SlashCommands.EventArgs.SlashCommandExecutedEventArgs args)
        {
            string logMessage = $"`{args.Context.User.Username}` ran `/{args.Context.CommandName}` in **[{(args.Context.Guild != null ? $"{args.Context.Guild.Name} - {args.Context.Channel.Name}" : "DM")}]**";

            this.bloonLog.Information(LogConsole.Commands, CommandEmojis.Run, logMessage);

            Log.Debug(logMessage);

            using IServiceScope scope = this.scopeFactory.CreateScope();
            using AnalyticsContext db = scope.ServiceProvider.GetRequiredService <AnalyticsContext>();

            db.Commands.Add(new Analytics.Commands()
            {
                Command   = args.Context.CommandName,
                Guild     = args.Context.Guild != null ? args.Context.Guild.Id : ulong.MinValue,
                Channel   = args.Context.Channel != null ? args.Context.Channel.Id : ulong.MinValue,
                UserId    = args.Context.User.Id,
                Link      = args.Context.Guild != null ? $"https://discord.com/channels/{args.Context.Guild.Id}/{args.Context.Channel.Id}/{args.Context.User.Id}" : "DM",
                Timestamp = DateTime.Now,
            });

            await db.SaveChangesAsync();

            return;
        }
Esempio n. 5
0
        private async Task OnContextMenuErrored(SlashCommandsExtension sender, DSharpPlus.SlashCommands.EventArgs.ContextMenuErrorEventArgs args)
        {
            if (args.Exception is ContextMenuExecutionChecksFailedException)
            {
                await args.Context.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder().WithContent("You do not have permission to do this.").AsEphemeral(true));

                return;
            }

            Log.Error(args.Exception, $"Command '{args.Context.CommandName}' errored");
            this.bloonLog.Error($"`{args.Context.User.Username}` ran `{args.Context.CommandName}` in **[{args.Context.Guild?.Name ?? "DM"} - {args.Context.Channel.Name}]**: {args.Exception.Message}");
        }
Esempio n. 6
0
        public async Task RunAsync()
        {
            var json  = string.Empty;
            var json1 = string.Empty;
            var json2 = string.Empty;

            using (var fs = File.OpenRead("AllTheLogin.json")) {
                using (var sr = new StreamReader(fs, new UTF8Encoding(false))) {
                    json = await sr.ReadToEndAsync().ConfigureAwait(false);
                }
            }
            using (var fs = File.OpenRead("AvatarHashes.json")) {
                using (var sr = new StreamReader(fs, new UTF8Encoding(false))) {
                    json1 = await sr.ReadToEndAsync().ConfigureAwait(false);
                }
            }
            using (var fs = File.OpenRead("AllTheStatus.json")) {
                using (var sr = new StreamReader(fs, new UTF8Encoding(false))) {
                    json2 = await sr.ReadToEndAsync().ConfigureAwait(false);
                }
            }

            loginJson  = JsonConvert.DeserializeObject <LoginInfo>(json);
            bigJson    = JsonConvert.DeserializeObject <AH>(json1);
            statusJson = JsonConvert.DeserializeObject <SS>(json2);

            ftpClient = new FtpClient(loginJson.hostName, 21, loginJson.userName, loginJson.passWord);

            var config0 = new DiscordConfiguration {
                Token         = loginJson.botToken,
                AutoReconnect = true,
                TokenType     = TokenType.Bot,
                Intents       = DiscordIntents.All
            };

            discord = new DiscordClient(config0);

            SlashCommandsExtension commands = discord.UseSlashCommands();

            commands.RegisterCommands <SVCommands>();

            avatarEmbed = new DiscordEmbedBuilder {
                Title = "Avatar Update!"
            };

            discord.GuildMemberUpdated += MemberUpdated;


            await discord.ConnectAsync();

            discord.Ready += BotReady;
            await Task.Delay(-1);
        }
Esempio n. 7
0
        private async Task SlashCommandService_CommandErrored(SlashCommandsExtension sc, SlashCommandErrorEventArgs e)
        {
            e.Context.Client.Logger.LogError(TestBotEventId, e.Exception, "Exception occurred during {User}'s invocation of '{Command}'", e.Context.User.Username, e.Context.CommandName);

            var emoji = DiscordEmoji.FromName(e.Context.Client, ":no_entry:");

            // let's wrap the response into an embed
            var embed = new DiscordEmbedBuilder {
                Title       = "Error",
                Description = $"{emoji} Error!",
                Color       = new DiscordColor(0xFF0000) // red
            };
            await e.Context.CreateResponseAsync(embed);
        }
        public ClientEventHandler(DiscordClient client, SlashCommandsExtension slash, IMongoConnection mongo)
        {
            this._client = client;
            this._slash  = slash;
            this._mongo  = mongo;

            this._client.Ready += (_, _) =>
            {
                Console.WriteLine($"{this._client.CurrentUser.Username} ready.");
                return(Task.CompletedTask);
            };

            this._slash.SlashCommandErrored += async(s, args) =>
            {
                if (args.Exception is SlashExecutionChecksFailedException slex)
                {
                    foreach (var check in slex.FailedChecks)
                    {
                        switch (check)
                        {
                        case SlashRequireUserPermissionsAttribute slashRequireUserPermissionsAttribute:
                            var ruContent =
                                $"Not enough permissions. You need: {slashRequireUserPermissionsAttribute.Permissions.ToPermissionString()}";
                            await args.Context.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
                                                                   new DiscordInteractionResponseBuilder().WithContent(ruContent).AsEphemeral(true));

                            break;

                        case SlashRequireOwnerAttribute slashRequireOwnerAttribute:
                            var roContent =
                                $"You have to be a bot owner to use that command.";
                            await args.Context.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
                                                                   new DiscordInteractionResponseBuilder().WithContent(roContent).AsEphemeral(true));

                            break;

                        case SlashRequiredChannelsAttribute slashRequiredChannelsAttribute:
                            var rcContent =
                                $"You can only use this command in allowed channels, such as {String.Join(", ", slashRequiredChannelsAttribute.RequiredChannels.Select(x => $"<#{x}>"))}";
                            await args.Context.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
                                                                   new DiscordInteractionResponseBuilder().WithContent(rcContent).AsEphemeral(true));

                            break;
                        }
                    }
                }
            };
        }
Esempio n. 9
0
        public override Task Initialize()
        {
            this.cNext = this.dClient.UseCommandsNext(new CommandsNextConfiguration
            {
                Services       = this.provider,
                StringPrefixes = Environment.GetEnvironmentVariable("COMMAND_PREFIXES").Split(","),
            });

            this.slash = this.dClient.UseSlashCommands(new SlashCommandsConfiguration
            {
                Services = this.provider,
            });

            AppDomain.CurrentDomain.ProcessExit += this.OnShutdown;

            return(base.Initialize());
        }
Esempio n. 10
0
        public static async Task CommandErrored(SlashCommandsExtension slashCommandExtension, SlashCommandErrorEventArgs slashCommandErrorEventArgs)
        {
            if (slashCommandErrorEventArgs.Exception is SlashExecutionChecksFailedException)
            {
                return;
            }
            else if (slashCommandErrorEventArgs.Exception is InvalidOperationException && slashCommandErrorEventArgs.Exception.Message == "A slash command was executed, but no command was registered for it.")
            {
                return;
            }
            DiscordChannel discordChannel = await slashCommandExtension.Client.GetChannelAsync(832374606748188743);

            DiscordMessageBuilder discordMessageBuilder = new();
            string stackTrace = string.Join("\n\n", slashCommandErrorEventArgs.Exception.StackTrace.Split('\n').Select(line => line.Trim())).Truncate(1800);

            discordMessageBuilder.Content = $"`/{slashCommandErrorEventArgs.Context.CommandName}` threw a {slashCommandErrorEventArgs.Exception.GetType()}: {slashCommandErrorEventArgs.Exception.Message ?? "<no message>"}\n{Formatter.BlockCode(stackTrace, "cs")}";
            await discordChannel.SendMessageAsync(discordMessageBuilder);
        }
Esempio n. 11
0
        public static async Task CommandErrored(SlashCommandsExtension slashCommandExtension, SlashCommandExecutedEventArgs slashCommandExecutedEventArgs)
        {
            using IServiceScope scope = Program.ServiceProvider.CreateScope();
            Database database = scope.ServiceProvider.GetService <Database>();

            if (slashCommandExecutedEventArgs.Context.Guild == null)
            {
                return;
            }

            GuildMember guildMember = database.GuildMembers.FirstOrDefault(user => user.UserId == slashCommandExecutedEventArgs.Context.Member.Id && user.GuildId == slashCommandExecutedEventArgs.Context.Guild.Id);

            if (guildMember == null)
            {
                database.AddGuildMember(slashCommandExecutedEventArgs.Context.Member);
                await database.SaveChangesAsync();
            }
            slashCommandExecutedEventArgs.Handled = true;
        }
Esempio n. 12
0
 public LTPFeature(DiscordClient dClient)
 {
     this.cNext = dClient.GetCommandsNext();
     this.slash = dClient.GetSlashCommands();
 }
Esempio n. 13
0
        public async Task RunAsync()
        {
            ReadConfig.Read();
            var  varrepo = new VariableRepository(ReadConfig.Config.ConnectionString);
            bool result;

#if DEBUG
            result = varrepo.Read(3, out Variable prefix);             //get testPrefix if in designmode
#else
            result = varrepo.Read(2, out Variable prefix);             //otherwise get default prefix
#endif
            DiscordConfiguration config = new DiscordConfiguration
            {
                Token         = ReadConfig.Config.Token,
                TokenType     = TokenType.Bot,
                AutoReconnect = true,
#if DEBUG
                MinimumLogLevel = Microsoft.Extensions.Logging.LogLevel.Debug,
#endif
                Intents = DiscordIntents.All
            };

            Client = new DiscordClient(config);

            //Register client events
            Client.Ready += Events.OnClientReady;
            Client.GuildDownloadCompleted      += Events.Client_GuildDownloadCompleted;
            Client.MessageCreated              += Events.MessageCreated;
            Client.MessageUpdated              += Events.MessageUpdated;
            Client.MessageDeleted              += Events.MessageDeleted;
            Client.GuildMemberAdded            += Events.MemberAdded;
            Client.MessageReactionAdded        += Events.ReactionAdded;
            Client.MessageReactionRemoved      += Events.ReactionRemoved;
            Client.VoiceStateUpdated           += Events.VoiceStateUpdated;
            Client.ClientErrored               += Events.ClientErrored;
            Client.ComponentInteractionCreated += Events.ComponentTriggered;

            //Register client events for logging
            Client.GuildBanAdded       += Logger.BanAdded;
            Client.GuildBanRemoved     += Logger.BanRemoved;
            Client.GuildMemberUpdated  += Logger.MemberUpdated;
            Client.ChannelUpdated      += Logger.ChannelUpdated;
            Client.GuildRoleUpdated    += Logger.RoleUpdated;
            Client.MessageUpdated      += Logger.MessageEdited;
            Client.MessageDeleted      += Logger.MessageDeleted;
            Client.MessagesBulkDeleted += Logger.BulkMessagesDeleted;
            //Client.GuildEmojisUpdated += Logger.EmojiUpdated;
            Client.VoiceStateUpdated += Logger.VoiceUpdate;


            //Register timer events
            SystemService.Instance.WarnTimer.Elapsed += Events.TimerTick;

            //Register Logger events
            SystemService.Instance.Logger.RaiseLogEvent += Events.OnLog;

            Client.UseInteractivity(new InteractivityConfiguration
            {
                Timeout              = TimeSpan.FromMinutes(5),
                PollBehaviour        = PollBehaviour.KeepEmojis,
                AckPaginationButtons = true
            });

            CommandsNextConfiguration commandsConfig = new CommandsNextConfiguration
            {
                StringPrefixes      = new string[] { prefix.Value },
                EnableMentionPrefix = true
            };
            Commands = Client.UseCommandsNext(commandsConfig);

            //Register commands
            Commands.RegisterCommands <AuditCommands>();
            Commands.RegisterCommands <EmbedCommands>();
            Commands.RegisterCommands <InfoCommands>();
            Commands.RegisterCommands <LavalinkCommands>();
            Commands.RegisterCommands <ReactionCommands>();
            Commands.RegisterCommands <RuleCommands>();
            Commands.RegisterCommands <TechnicalCommands>();
            Commands.RegisterCommands <WarnCommands>();
            Commands.RegisterCommands <EventCommands>();

            //Register command events
            Commands.CommandErrored += Events.CommandErrored;

            SlashCommands = Client.UseSlashCommands();

            //Register interactions
            SlashCommands.RegisterCommands <WarnInteractions>(699555747591094344);

            //Register interaction events
            SlashCommands.ContextMenuErrored += Events.ContextMenuErrored;

            await Client.ConnectAsync();

            LavalinkNodeConnection lavaNode = null;
            lavaNode = await ConnectLavaNodeAsync();

            if (lavaNode != null)
            {
                //Register lava commands
                lavaNode.PlaybackFinished += Events.PlaybackFinished;
            }

            await Task.Delay(-1);
        }
Esempio n. 14
0
        static async Task MainAsync(string[] args)
        {
            //Настройка базовой конфигурации бота
            DiscordConfiguration DiscordConfig = new DiscordConfiguration {
                Token           = DiscordToken,
                TokenType       = TokenType.Bot,
                MinimumLogLevel = Microsoft.Extensions.Logging.LogLevel.Debug,
                Intents         = DiscordIntents.AllUnprivileged
            };

            discord = new DiscordClient(DiscordConfig);

            string[] Prefixes = new string[1];
            Prefixes[0] = "!!";

            //Настройка списка комманд
            CommandsNextConfiguration commandsConfig = new CommandsNextConfiguration {
                StringPrefixes      = Prefixes,
                EnableMentionPrefix = true
            };

            InteractivityConfiguration interactivityConfig = new InteractivityConfiguration {
                PollBehaviour = DSharpPlus.Interactivity.Enums.PollBehaviour.KeepEmojis,
                Timeout       = TimeSpan.FromSeconds(30)
            };

            SlashCommandsExtension slashCommands = discord.UseSlashCommands();

            //slashCommands.RegisterCommands<MyCommands>();


            commands = discord.UseCommandsNext(commandsConfig);
            commands.RegisterCommands <MyCommands> ();
            commands.RegisterCommands <VozhbanCommands> ();
            MyCommands.FillList();
            VozhbanCommands.LoadText();
            Console.WriteLine("Bot staterted 3.0");


            //Working when readction added
            discord.MessageReactionAdded += Clock;
            discord.MessageReactionAdded += Permission;
            discord.MessageCreated       += RollDice;
            discord.MessageCreated       += RollXDice;
            discord.MessageCreated       += TolpojDS;


            async Task Clock(DiscordClient discordClient, MessageReactionAddEventArgs context)
            {
                if (context.Emoji.Name == "⏲")
                {
                    string Respond = context.User.Username + " готов поиграть в ДС!";
                    if (PartyCount > 0)
                    {
                        Respond += "\n Кстати в войсе уже " + PartyCount + " людей!";
                    }
                    await context.Message.RespondAsync(Respond);
                }
            }

            await discord.ConnectAsync();

            async Task Permission(DiscordClient discordClient, MessageReactionAddEventArgs context)
            {
                if (context.Emoji.Name == "🔫")
                {
                    await context.Message.RespondAsync(context.Message.Author.Username + " расстрелян");
                }
            }

            async Task TolpojDS(DiscordClient discordClient, MessageCreateEventArgs context)
            {
                string message = context.Message.Content;

                if (message.Contains("<@&515543976678391808>"))                   //("<@&515543976678391808>")) {
                {
                    await context.Message.CreateReactionAsync(DiscordEmoji.FromName(discordClient, ":r1:", true));

                    await context.Message.CreateReactionAsync(DiscordEmoji.FromName(discordClient, ":g6:", true));
                }
            }

            async Task RollXDice(DiscordClient discordClient, MessageCreateEventArgs context)
            {
                string Message = context.Message.Content.ToLower();

                int d = Message.IndexOf("r");

                if (d != -1)
                {
                    string Respond   = "";
                    int    RollCount = 0;
                    int    s         = Message.IndexOf("+");
                    int    Mod       = 0;
                    int    Sides     = 0;
                    int    Sum       = 0;
                    string Sign      = "";
                    string Side      = "";
                    Random Die       = new Random();

                    if (s == -1)
                    {
                        s = Message.IndexOf("-");
                    }

                    if (s != -1)
                    {
                        if (int.TryParse(Message.Remove(0, s), out Mod) == true)
                        {
                            if (Mod > 0)
                            {
                                Sign = "+";
                            }
                        }
                        Side = Message.Remove(s);
                    }
                    else
                    {
                        Mod  = 0;
                        Side = Message;
                    }

                    if (d == 0)
                    {
                        RollCount = 1;
                    }
                    else
                    {
                        if (int.TryParse(Message.Remove(d), out RollCount) == true)
                        {
                            if (RollCount <= 0)
                            {
                                RollCount = 0;
                                Respond   = context.Message.Author.Mention + " роняет кубы, выкидывает **-11** и страдает. За тупость.\n";
                            }
                        }
                    }

                    if (int.TryParse(Side.Remove(0, d + 1), out Sides) == true)
                    {
                        if (Sides <= 0)
                        {
                            RollCount = 0;
                            Respond   = context.Message.Author.Mention + " роняет кубы, выкидывает **-11** и страдает. За тупость.\n";
                        }
                    }
                    else
                    {
                        RollCount = 0;
                    }

                    if ((Message.Length == d + 1) || (Message.Length == s + 1) || (s == d + 1))
                    {
                        RollCount = 0;
                    }

                    if (RollCount == 1)
                    {
                        int Dice = Die.Next(1, Sides + 1);
                        if (Mod == 0)
                        {
                            Respond += context.Message.Author.Mention + " кидает " + Sides + "-гранник и выкидывает **" + Dice + "**\n";
                        }
                        else
                        {
                            Respond += context.Message.Author.Mention + " кидает " + Sides + "-гранник и выкидывает " + Dice + Sign + Mod + " = **" + (Dice + Mod) + "**\n";
                        }
                    }
                    else if (RollCount > 1)
                    {
                        if (Mod == 0)
                        {
                            Respond += context.Message.Author.Mention + " кидает " + Sides + "-гранник " + RollCount + " раз и выкидывает **";
                        }
                        else
                        {
                            Respond += context.Message.Author.Mention + " кидает " + Sides + "-гранник [" + Sign + Mod + "] " + RollCount + " раз и выкидывает **";
                        }
                        for (int i = 0; i < RollCount; i++)
                        {
                            int Dice = Die.Next(1, Sides + 1);
                            Sum     += Dice + Mod;
                            Respond += (Dice + Mod);
                            if (i == RollCount - 1)
                            {
                                Respond += "**.";
                            }
                            else
                            {
                                Respond += ", ";
                            }
                        }
                        Respond += "\nСумма: **" + Sum + "**";
                    }
                    await context.Message.RespondAsync(Respond);

                    await context.Message.DeleteAsync();
                }
            }

            async Task RollDice(DiscordClient discordClient, MessageCreateEventArgs context)
            {
                string Message = context.Message.Content.ToLower();

                int d = Message.IndexOf("d");

                if (d != -1)
                {
                    string Respond   = "";
                    int    RollCount = 0;
                    int    Mod       = 0;
                    int    Sum       = 0;
                    string Sign      = "";
                    Random GreenDie  = new Random();
                    Random RedDie    = new Random();

                    if (d == 0)
                    {
                        RollCount = 1;
                    }
                    else
                    {
                        if (int.TryParse(Message.Remove(d), out RollCount) == true)
                        {
                            if (RollCount <= 0)
                            {
                                RollCount = 0;
                                Respond   = context.Message.Author.Mention + " роняет кубы, выкидывает **-11** и страдает. За тупость.\n";
                            }
                        }
                    }
                    Console.Write("Message" + context.Message.Content + " RollCount: " + RollCount);

                    if (int.TryParse(Message.Remove(0, d + 1), out Mod) == true)
                    {
                        if (Mod >= 0)
                        {
                            Sign = "+";
                        }
                    }

                    if (RollCount == 1)
                    {
                        int    Green = GreenDie.Next(1, 7);
                        int    Red   = RedDie.Next(1, 7);
                        string SignD = "";
                        string EmoGreenDie;
                        string EmoRedDie;
                        EmoGreenDie = DiscordEmoji.FromName(discordClient, ":g" + Green + ":", true).ToString();
                        EmoRedDie   = DiscordEmoji.FromName(discordClient, ":r" + Red + ":", true).ToString();

                        if (Green - Red + Mod > 0)
                        {
                            SignD = "+";
                        }

                        /*if (Message.Length == d+1) {
                         *      Respond += context.Message.Author.Mention + " выкидывает " + EmoGreenDie + EmoRedDie + " | " + Green + " - " + Red + " = **" + SignD + (Green - Red);
                         *      return;
                         * }*/

                        if (Mod == 0)
                        {
                            Respond += context.Message.Author.Mention + " выкидывает " + EmoGreenDie + EmoRedDie + " | " + Green + " - " + Red + " = **" + SignD + (Green - Red);
                        }
                        else
                        {
                            Respond += context.Message.Author.Mention + " выкидывает " + EmoGreenDie + EmoRedDie + " | " + Green + " - " + Red + " " + Sign + Mod + " = **" + SignD + (Green - Red + Mod);
                        }
                        if ((Green - Red) == 5)
                        {
                            Respond += ". Критический Успех";
                        }
                        else if ((Green - Red) == -5)
                        {
                            Respond += ". Критический Провал";
                        }
                        Respond += "**";
                    }
                    else if (RollCount > 1)
                    {
                        if (Mod == 0)
                        {
                            Respond += context.Message.Author.Mention + " кидает кубы " + RollCount + " раз и выкидывает **";
                        }
                        else
                        {
                            Respond += context.Message.Author.Mention + " кидает кубы [" + Sign + Mod + "] " + RollCount + " раз и выкидывает **";
                        }
                        for (int i = 0; i < RollCount; i++)
                        {
                            int    Green = GreenDie.Next(1, 7);
                            int    Red   = RedDie.Next(1, 7);
                            string SignD = "";
                            if (Green - Red + Mod > 0)
                            {
                                SignD = "+";
                            }
                            Sum += Green - Red + Mod;
                            if ((Green - Red) == 5)
                            {
                                Respond += "{__" + SignD + (Green - Red + Mod) + "__}";
                            }
                            else if ((Green - Red) == -5)
                            {
                                Respond += "(__" + SignD + (Green - Red + Mod) + "__)";
                            }
                            else
                            {
                                Respond += SignD + (Green - Red + Mod);
                            }
                            if (i == RollCount - 1)
                            {
                                Respond += "**.";
                            }
                            else
                            {
                                Respond += ", ";
                            }
                        }
                        Respond += "\nСумма: **" + Sum + "**";
                    }

                    await context.Message.RespondAsync(Respond);

                    await context.Message.DeleteAsync();
                }
            }

            /*
             * async Task StatCheck (MessageCreateEventArgs context) {
             *
             *      string Message = context.Message.Content.ToLower();
             *
             *      if (Message[0] == 'd') {
             *
             *              string Respond = "";
             *              //Бросаем 2 d6
             *              Random FirstD6  = new Random ();
             *              Random SecondD6 = new Random ();
             *              int First  = FirstD6 .Next (1,7);
             *              int Second = SecondD6.Next (1,7);
             *
             *              string GreenDie;
             *              string RedDie;
             *
             *              GreenDie = DSharpPlus.Entities.DiscordEmoji.FromName(discord, ":g" + First + ":").ToString();
             *              RedDie   = DSharpPlus.Entities.DiscordEmoji.FromName(discord, ":r" + Second + ":").ToString();
             *
             *              if (Message.Length == 1) {
             *                      Respond = context.Message.Author.Mention + " выкидывает " + GreenDie + RedDie + " | " + First + "-" + Second + "= **" + (First - Second) + "**";
             *              }
             *              else {
             *                      int Side = 0;
             *
             *                      if (Message.Length > 2 && Message[1] == '-') {
             *                              if (int.TryParse (Message.Remove (0,2), out Side) == true) {
             *                                      Random random  = new Random ();
             *                                      int Result = random.Next (1, Side);
             *                                      Respond = context.Message.Author.Mention + " выкидывает " + GreenDie + RedDie + " | " + First + "-" + Second + "-" + Side + "= **" + (First - Second - Side) + "**";
             *                              }
             *                      }
             *                      else {
             *
             *                              if (int.TryParse (Message.Remove (0,1), out Side) == true) {
             *                                      Random random  = new Random ();
             *                                      int Result = 0;
             *                                      if (Side > 1) {
             *                                              Result = random.Next (1, Side);
             *                                      }
             *                                      Respond = context.Message.Author.Mention + " выкидывает " + GreenDie + RedDie + " | " + First + "-" + Second + "+" + Side + "= **" + (First - Second + Side) + "**";
             *                              }
             *                      }
             *              }
             *              await context.Message.RespondAsync (Respond);
             *              await context.Message.DeleteAsync ();
             *      }
             * }
             */

            //Позволяет печатать прямо из консоли в любой канал, при отправке в azure лучше закоментить этот код
            //while(true) {
            //	string Message = Console.ReadLine ();
            //	DSharpPlus.Entities.DiscordChannel channel = await discord.GetChannelAsync (292562693993529349);//NSFW Science 439527469897351178 //Bot log 530096997726945317
            //	await discord.SendMessageAsync (channel, Message);
            //}

            await Task.Delay(-1);
        }
Esempio n. 15
0
 private Task SlashCommandService_CommandExecuted(SlashCommandsExtension sc, SlashCommandExecutedEventArgs e)
 {
     e.Context.Client.Logger.LogInformation(TestBotEventId, "User {User} executed '{Command}' in {Channel}", e.Context.User.Username, e.Context.CommandName, e.Context.Channel.Name);
     return(Task.CompletedTask);
 }
Esempio n. 16
0
        public TestBot(TestBotConfig cfg, int shardid)
        {
            // global bot config
            this.Config = cfg;

            // discord instance config and the instance itself
            var dcfg = new DiscordConfiguration
            {
                AutoReconnect      = true,
                LargeThreshold     = 250,
                MinimumLogLevel    = LogLevel.Trace,
                Token              = this.Config.Token,
                TokenType          = TokenType.Bot,
                ShardId            = shardid,
                ShardCount         = this.Config.ShardCount,
                MessageCacheSize   = 2048,
                LogTimestampFormat = "dd-MM-yyyy HH:mm:ss zzz",
                Intents            = DiscordIntents.All // if 4013 is received, change to DiscordIntents.AllUnprivileged
            };

            this.Discord = new DiscordClient(dcfg);

            // events
            this.Discord.Ready += this.Discord_Ready;
            this.Discord.GuildStickersUpdated += this.Discord_StickersUpdated;
            this.Discord.GuildAvailable       += this.Discord_GuildAvailable;
            //Discord.PresenceUpdated += this.Discord_PresenceUpdated;
            //Discord.ClientErrored += this.Discord_ClientErrored;
            this.Discord.SocketErrored          += this.Discord_SocketError;
            this.Discord.GuildCreated           += this.Discord_GuildCreated;
            this.Discord.VoiceStateUpdated      += this.Discord_VoiceStateUpdated;
            this.Discord.GuildDownloadCompleted += this.Discord_GuildDownloadCompleted;
            this.Discord.GuildUpdated           += this.Discord_GuildUpdated;
            this.Discord.ChannelDeleted         += this.Discord_ChannelDeleted;

            this.Discord.InteractionCreated          += this.Discord_InteractionCreated;
            this.Discord.ComponentInteractionCreated += this.Discord_ModalCheck;
            this.Discord.ModalSubmitted += this.Discord_ModalSubmitted;
            //this.Discord.ComponentInteractionCreated += this.RoleMenu;
            //this.Discord.ComponentInteractionCreated += this.DiscordComponentInteractionCreated;
            //this.Discord.InteractionCreated += this.SendButton;
            // For event timeout testing
            //Discord.GuildDownloadCompleted += async (s, e) =>
            //{
            //    await Task.Delay(TimeSpan.FromSeconds(2)).ConfigureAwait(false);
            //    throw new Exception("Flippin' tables");
            //};

            this.Discord.ThreadCreated        += this.Discord_ThreadCreated;
            this.Discord.ThreadUpdated        += this.Discord_ThreadUpdated;
            this.Discord.ThreadDeleted        += this.Discord_ThreadDeleted;
            this.Discord.ThreadListSynced     += this.Discord_ThreadListSynced;
            this.Discord.ThreadMemberUpdated  += this.Discord_ThreadMemberUpdated;
            this.Discord.ThreadMembersUpdated += this.Discord_ThreadMembersUpdated;

            // voice config and the voice service itself
            var vcfg = new VoiceNextConfiguration
            {
                AudioFormat    = AudioFormat.Default,
                EnableIncoming = true
            };

            this.VoiceService = this.Discord.UseVoiceNext(vcfg);

            // build a dependency collection for commandsnext
            var depco = new ServiceCollection();

            // commandsnext config and the commandsnext service itself
            var cncfg = new CommandsNextConfiguration
            {
                StringPrefixes           = this.Config.CommandPrefixes,
                EnableDms                = true,
                EnableMentionPrefix      = true,
                CaseSensitive            = false,
                Services                 = depco.BuildServiceProvider(true),
                IgnoreExtraArguments     = false,
                UseDefaultCommandHandler = true,
                DefaultParserCulture     = CultureInfo.InvariantCulture,
                //CommandExecutor = new ParallelQueuedCommandExecutor(2),
            };

            this.CommandsNextService = this.Discord.UseCommandsNext(cncfg);
            this.CommandsNextService.CommandErrored  += this.CommandsNextService_CommandErrored;
            this.CommandsNextService.CommandExecuted += this.CommandsNextService_CommandExecuted;
            this.CommandsNextService.RegisterCommands(typeof(TestBot).GetTypeInfo().Assembly);
            this.CommandsNextService.SetHelpFormatter <TestBotHelpFormatter>();

            // interactivity service
            var icfg = new InteractivityConfiguration()
            {
                Timeout = TimeSpan.FromSeconds(10),
                AckPaginationButtons = true,
                ResponseBehavior     = InteractionResponseBehavior.Respond,
                PaginationBehaviour  = PaginationBehaviour.Ignore,
                ResponseMessage      = "Sorry, but this wasn't a valid option, or does not belong to you!",
                PaginationButtons    = new PaginationButtons()
                {
                    Stop      = new DiscordButtonComponent(ButtonStyle.Danger, "stop", null, false, new DiscordComponentEmoji(862259725785497620)),
                    Left      = new DiscordButtonComponent(ButtonStyle.Secondary, "left", null, false, new DiscordComponentEmoji(862259522478800916)),
                    Right     = new DiscordButtonComponent(ButtonStyle.Secondary, "right", null, false, new DiscordComponentEmoji(862259691212242974)),
                    SkipLeft  = new DiscordButtonComponent(ButtonStyle.Primary, "skipl", null, false, new DiscordComponentEmoji(862259605464023060)),
                    SkipRight = new DiscordButtonComponent(ButtonStyle.Primary, "skipr", null, false, new DiscordComponentEmoji(862259654403031050))
                }
            };

            this.InteractivityService = this.Discord.UseInteractivity(icfg);
            this.LavalinkService      = this.Discord.UseLavalink();

            this.SlashCommandService = this.Discord.UseSlashCommands();
            this.SlashCommandService.SlashCommandErrored  += this.SlashCommandService_CommandErrored;
            this.SlashCommandService.SlashCommandInvoked  += this.SlashCommandService_CommandReceived;
            this.SlashCommandService.SlashCommandExecuted += this.SlashCommandService_CommandExecuted;

            if (this.Config.SlashCommandGuild != 0)
            {
                this.SlashCommandService.RegisterCommands(typeof(TestBot).GetTypeInfo().Assembly, this.Config.SlashCommandGuild);
            }

            //this.Discord.MessageCreated += async e =>
            //{
            //    if (e.Message.Author.IsBot)
            //        return;

            //    _ = Task.Run(async () => await e.Message.RespondAsync(e.Message.Content)).ConfigureAwait(false);
            //};
        }
Esempio n. 17
0
        private async Task RestartBot(DiscordSettings previousSettings, DiscordSettings newSettings, HashSet <ulong> currentGuilds)
        {
            if (!string.IsNullOrEmpty(newSettings.BotToken))
            {
                if (!string.Equals(previousSettings.BotToken, newSettings.BotToken, StringComparison.OrdinalIgnoreCase))
                {
                    if (_client != null)
                    {
                        await _client.DisconnectAsync();

                        _client.Ready -= Connected;
                        _client.ComponentInteractionCreated -= DiscordComponentInteractionCreatedHandler;
                        _client.Dispose();
                    }

                    if (_slashCommands != null)
                    {
                        _slashCommands.SlashCommandErrored -= SlashCommandErrorHandler;
                    }

                    var config = new DiscordConfiguration()
                    {
                        Token                 = newSettings.BotToken,
                        TokenType             = TokenType.Bot,
                        AutoReconnect         = true,
                        MinimumLogLevel       = LogLevel.Warning,
                        Intents               = DiscordIntents.All,
                        ReconnectIndefinitely = true
                    };

                    _client = new DiscordClient(config);

                    _slashCommands = _client.UseSlashCommands(new SlashCommandsConfiguration
                    {
                        Services = new ServiceCollection()
                                   .AddSingleton <DiscordClient>(_client)
                                   .AddSingleton <ILogger>(_logger)
                                   .AddSingleton <DiscordSettingsProvider>(_discordSettingsProvider)
                                   .AddSingleton <MovieWorkflowFactory>(_movieWorkflowFactory)
                                   .AddSingleton <TvShowWorkflowFactory>(_tvShowWorkflowFactory)
                                   .BuildServiceProvider()
                    });

                    _slashCommands.SlashCommandErrored += SlashCommandErrorHandler;

                    _client.Ready += Connected;
                    _client.ComponentInteractionCreated += DiscordComponentInteractionCreatedHandler;

                    _currentGuilds = new HashSet <ulong>();
                    await _client.ConnectAsync();
                }

                if (_client != null)
                {
                    if (_client.Guilds.Any())
                    {
                        await ApplyBotConfigurationAsync(newSettings);

                        var prop = _slashCommands.GetType().GetProperty("_updateList", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
                        prop.SetValue(_slashCommands, new List <KeyValuePair <ulong?, Type> >());

                        var slashCommandType = SlashCommandBuilder.Build(_logger, newSettings, _serviceProvider.Get <RadarrSettingsProvider>(), _serviceProvider.Get <SonarrSettingsProvider>(), _serviceProvider.Get <OverseerrSettingsProvider>());

                        if (newSettings.EnableRequestsThroughDirectMessages)
                        {
                            try { _slashCommands.RegisterCommands(slashCommandType); }
                            catch (System.Exception ex) { _logger.LogError(ex, "Error while registering global slash commands: " + ex.Message); }

                            foreach (var guildId in _client.Guilds.Keys)
                            {
                                try { _slashCommands.RegisterCommands <EmptySlashCommands>(guildId); }
                                catch (System.Exception ex) { _logger.LogError(ex, $"Error while emptying guild-specific slash commands for guid {guildId}: " + ex.Message); }
                            }
                        }
                        else
                        {
                            try { _slashCommands.RegisterCommands <EmptySlashCommands>(); }
                            catch (System.Exception ex) { _logger.LogError(ex, "Error while emptying global slash commands: " + ex.Message); }

                            foreach (var guildId in _client.Guilds.Keys)
                            {
                                try { _slashCommands.RegisterCommands(slashCommandType, guildId); }
                                catch (System.Exception ex) { _logger.LogError(ex, $"Error while registering guild-specific slash commands for guid {guildId}: " + ex.Message); }
                            }
                        }

                        await _slashCommands.RefreshCommands();

                        await Task.Delay(TimeSpan.FromMinutes(1));
                    }
                }
                else
                {
                    _logger.LogWarning("No Bot Token for Discord has been configured.");
                }
            }
        }