public Bot(BotConfig botConfig, DBConfig dBConfig) { DiscordConfiguration discordConfiguration = new DiscordConfiguration { Token = botConfig.Token, TokenType = TokenType.Bot, LogLevel = LogLevel.Debug, UseInternalLogHandler = true, ShardCount = 1, ShardId = 0 }; ServiceProvider deps = new ServiceCollection() .AddSingleton(httpClient) .AddSingleton(utility) .AddSingleton(new WeebShAPIClient(botConfig.WeebSHToken, httpClient)) .AddDbContext <LanguageManager>(x => x.UseNpgsql(dBConfig.ConnString), ServiceLifetime.Transient) .AddDbContext <UserManager>(x => x.UseNpgsql(dBConfig.ConnString), ServiceLifetime.Transient) .BuildServiceProvider(); CommandsNextConfiguration commandsNextConfiguration = new CommandsNextConfiguration { StringPrefixes = new [] { botConfig.BetaPrefix }, Services = deps }; InteractivityConfiguration interactivityConfiguration = new InteractivityConfiguration { PaginationBehaviour = PaginationBehaviour.WrapAround, PaginationDeletion = PaginationDeletion.DeleteEmojis, PollBehaviour = PollBehaviour.DeleteEmojis }; VoiceNextConfiguration voiceNextConfiguration = new VoiceNextConfiguration { AudioFormat = AudioFormat.Default }; this.discordClient = new DiscordClient(discordConfiguration); this.commandsNextExtension = this.discordClient.UseCommandsNext(commandsNextConfiguration); this.interactivityExtension = this.discordClient.UseInteractivity(interactivityConfiguration); this.voiceNextExtension = this.discordClient.UseVoiceNext(voiceNextConfiguration); this.discordClient.ClientErrored += e => {; Console.WriteLine("Client Error:"); Console.WriteLine(e.EventName); Console.WriteLine(e.Exception); return(Task.CompletedTask); }; this.discordClient.SocketErrored += e => { Console.WriteLine("Socket Error:"); Console.WriteLine(e.Exception); return(Task.CompletedTask); }; this.discordClient.GuildDownloadCompleted += e => { this.commandsNextExtension.RegisterCommands <Dev>(); foreach (var f in Directory.EnumerateFiles(@"Commands\\")) { using (ZipFile zip = ZipFile.Read(@$ "{f}")) { var dll = zip.First(x => x.FileName.EndsWith(".dll")); var splitFileName = dll.FileName.Split('.'); var group = splitFileName[^ 2];
public void Initialize() { var config = new DiscordConfiguration() { Token = _appSettings.Keys.Discord, TokenType = TokenType.Bot, LogLevel = LogLevel.Debug, UseInternalLogHandler = true }; var vnConfig = new VoiceNextConfiguration() { VoiceApplication = VoiceApplication.Music, EnableIncoming = false }; Client = new DiscordClient(config); Client.UseVoiceNext(vnConfig); Client.SetWebSocketClient <WebSocket4NetCoreClient>(); Client.Ready += ClientOnReady; Client.GuildAvailable += ClientOnGuildAvailable; Client.SocketOpened += ClientOnSocketOpened; Client.ClientErrored += ClientOnClientErrored; Client.MessageCreated += ClientOnMessageCreated; Client.MessageUpdated += ClientOnMessageUpdated; Client.SocketClosed += ClientOnSocketClosed; }
/// <summary> /// Creates a new instance of <see cref="VoiceNextConfiguration"/>, copying the properties of another configuration. /// </summary> /// <param name="other">Configuration the properties of which are to be copied.</param> public VoiceNextConfiguration(VoiceNextConfiguration other) { this.AudioFormat = new AudioFormat(other.AudioFormat.SampleRate, other.AudioFormat.ChannelCount, other.AudioFormat.VoiceApplication); #if !NETSTANDARD1_1 this.EnableIncoming = other.EnableIncoming; #endif }
static async Task MainAsync(string[] args) { discord = new DiscordClient(new DiscordConfiguration { Token = DiscordoBotToken.myBotToken, TokenType = TokenType.Bot }); commands = discord.UseCommandsNext(new CommandsNextConfiguration { StringPrefix = "!" }); commands.RegisterCommands <DiscordoCommands>(); VoiceNextConfiguration vNextConfiguration = new VoiceNextConfiguration { VoiceApplication = VoiceApplication.Music }; voiceNextClient = discord.UseVoiceNext(vNextConfiguration); await discord.ConnectAsync(); await Task.Delay(-1); }
public JosephineBot(JosephineConfig cfg, int shardid) { Config = cfg; var dcfg = new DiscordConfiguration { AutoReconnect = true, LargeThreshold = 250, LogLevel = LogLevel.Debug, Token = Config.Token, TokenType = TokenType.Bot, UseInternalLogHandler = false, ShardId = shardid, ShardCount = Config.ShardCount, MessageCacheSize = 2048, DateTimeFormat = "dd-MM-yyyy HH:mm:ss zzz" }; debugMode = Config.debug; Discord = new DiscordClient(dcfg); Discord.DebugLogger.LogMessageReceived += this.DebugLogger_LogMessageRecieved; Discord.Ready += this.Client_Ready; Discord.ClientErrored += this.Client_ClientError; Discord.GuildUpdated += this.Discord_GuildUpdated; Discord.ChannelDeleted += this.Discord_ChannelDeleted; Discord.MessageCreated += this.Client_Chat; Discord.MessageUpdated += this.MessageUpdated; //Discord.GuildMemberAdded += this.Join_Chat; var vcfg = new VoiceNextConfiguration { AudioFormat = AudioFormat.Default, EnableIncoming = true }; VoiceService = Discord.UseVoiceNext(vcfg); var depco = new ServiceCollection(); // commandsnext config and the commandsnext service itself var cncfg = new CommandsNextConfiguration { StringPrefixes = Config.CommandPrefixes, EnableDms = false, EnableMentionPrefix = true, CaseSensitive = false, Services = depco.BuildServiceProvider(true), IgnoreExtraArguments = false, UseDefaultCommandHandler = true, }; this.CommandsNextService = Discord.UseCommandsNext(cncfg); this.CommandsNextService.CommandErrored += this.CommandsNextService_CommandErrored; this.CommandsNextService.CommandExecuted += this.Commands_CommandExecuted; this.CommandsNextService.RegisterCommands(typeof(JosephineBot).GetTypeInfo().Assembly); this.CommandsNextService.SetHelpFormatter <HelpFormatter>(); }
private void SetupVoice(DiscordClient client) { var voiceConf = new VoiceNextConfiguration { EnableIncoming = false, AudioFormat = AudioFormat.Default }; client.UseVoiceNext(voiceConf); }
public async Task RunAsync() { var json = string.Empty; using (var fs = File.OpenRead("config.json")) using (var sr = new StreamReader(fs, new UTF8Encoding(false))) json = await sr.ReadToEndAsync().ConfigureAwait(false); var configJson = JsonConvert.DeserializeObject <ConfigJson>(json); var config = new DiscordConfiguration { Token = configJson.Token, TokenType = TokenType.Bot, AutoReconnect = true, LogLevel = LogLevel.Debug, UseInternalLogHandler = true, }; Client = new DiscordClient(config); Client.Ready += OnClientReady; Client.UseInteractivity(new InteractivityConfiguration { Timeout = TimeSpan.FromMinutes(1) }); var commandsConfig = new CommandsNextConfiguration { StringPrefixes = new string[] { configJson.Prefix }, EnableDms = false, EnableMentionPrefix = true, }; Commands = Client.UseCommandsNext(commandsConfig); Commands.RegisterCommands <TestCommands>(); Commands.RegisterCommands <MusicCommands>(); var voiceConfiguration = new VoiceNextConfiguration { //configuration of voice }; Voice = Client.UseVoiceNext(voiceConfiguration); await Client.ConnectAsync(); await Task.Delay(-1); //fix for premature disconnect, delays eternally }
public async Task RunAsync() { var config = new DiscordConfiguration { Token = "", TokenType = TokenType.Bot, AutoReconnect = true, LogLevel = LogLevel.Debug, UseInternalLogHandler = true }; Client = new DiscordClient(config); Client.Ready += OnClientReady; Client.UseInteractivity(new InteractivityConfiguration { Timeout = TimeSpan.FromMinutes(2) }); var commandsConfig = new CommandsNextConfiguration { StringPrefix = "!", EnableDms = false, EnableMentionPrefix = true, EnableDefaultHelp = false }; Commands = Client.UseCommandsNext(commandsConfig); Commands.RegisterCommands <AslCommands>(); Commands.RegisterCommands <TTS>(); Commands.RegisterCommands <BslCommands>(); Commands.RegisterCommands <Hentai>(); var vcfg = new VoiceNextConfiguration { VoiceApplication = VoiceApplication.Music }; this.Voice = this.Client.UseVoiceNext(vcfg); await Client.ConnectAsync(); await Task.Delay(-1); }
private async Task RunAsync() { var json = string.Empty; await using (var fs = File.OpenRead("botconfig.json")) using (var sr = new StreamReader(fs, new UTF8Encoding(false))) json = await sr.ReadToEndAsync().ConfigureAwait(false); var configJson = JsonConvert.DeserializeObject <ConfigJson>(json); var config = new DiscordConfiguration { Token = configJson.Token, TokenType = TokenType.Bot, AutoReconnect = true, MinimumLogLevel = LogLevel.Warning, }; // Client = new DiscordShardedClient(config); Client = new DiscordShardedClient(config); Client.Ready += OnClientReady; var commandsConfig = new CommandsNextConfiguration { EnableMentionPrefix = true, EnableDms = false, EnableDefaultHelp = true }; await Client.UseCommandsNextAsync(commandsConfig); // Commands = Client.UseCommandsNext(commandsConfig); var voiceConfig = new VoiceNextConfiguration { EnableIncoming = false }; await Client.UseVoiceNextAsync(voiceConfig); await Client.StartAsync(); // await Client.ConnectAsync(); // await Task.Delay(-1); }
private static async Task MainAsync() { var data = new Global().DefaultDatabase(); _yone = new DiscordClient(new DiscordConfiguration { Token = data.botToken, TokenType = TokenType.Bot, UseInternalLogHandler = true, AutomaticGuildSync = true, AutoReconnect = true }); _commands = _yone.UseCommandsNext(new CommandsNextConfiguration { PrefixResolver = GetPrefixPositionAsync, EnableMentionPrefix = true, EnableDms = false, CaseSensitive = false, IgnoreExtraArguments = true }); _yone.UseInteractivity(new InteractivityConfiguration { PaginationBehavior = 0, PaginationTimeout = TimeSpan.FromMinutes(5.0), Timeout = TimeSpan.FromMinutes(2.0) }); var msc = new VoiceNextConfiguration { VoiceApplication = VoiceApplication.Music }; var dspExtended = _yone.UseDspExtended(); _commands.SetHelpFormatter <Help.DefaultHelpFormatter>(); _commands.RegisterCommands(Assembly.GetExecutingAssembly()); dspExtended.RegisterAssembly(Assembly.GetExecutingAssembly()); _yone.UseVoiceNext(msc); await _yone.ConnectAsync(); await Task.Delay(-1); }
public static async Task Login() { Utils.Log("Receiving token...", LogType.Console); Program.discord = new DiscordClient(new DiscordConfiguration() { //Token = DiscordLoginUtils.GetDiscordToken(), Token = "Mzc5NzUxMDc5MjAzNzAwNzQy.DScCfw.H5BHfhXw-ZwvN4DMgPTdmTRBJ_c", TokenType = DSharpPlus.TokenType.Bot, LogLevel = DSharpPlus.LogLevel.Debug, UseInternalLogHandler = true }); await Program.WaitReceiveToken(); Utils.Log("Received token.", LogType.Console); Program.SetupEvents(); await Onno204Bot.Events.Events.RegisterEvent(); Utils.Log("Setting up commands...", LogType.Console); Program.commands = Program.discord.UseCommandsNext(new CommandsNextConfiguration() { StringPrefix = Config.CommandString, CaseSensitive = false, EnableDefaultHelp = true }); Program.commands.RegisterCommands <Commands>(); Program.commands.CommandExecuted += new AsyncEventHandler <CommandExecutionEventArgs>(CommandsEvents.Commands_CommandExecuted); Utils.Log("Done Setting up commands.", LogType.Console); Utils.Log("Setting up Voice...", LogType.Console); VoiceNextConfiguration vcfg = new VoiceNextConfiguration() { EnableIncoming = true, VoiceApplication = VoiceApplication.Voice }; Program.Voice = Program.discord.UseVoiceNext(vcfg); Utils.Log("Done Setting up Voice.", LogType.Console); Utils.Log("Loggin in...", LogType.Console); await Program.discord.ConnectAsync(); Utils.Log("Logged in.", LogType.Console); await Task.Delay(-1); }
public Bot_Base(string serverName, DiscordConfiguration dsConfig, bool autostart = false) { try { ServerName = serverName; Client = new DiscordClient(dsConfig); var ccfg = new CommandsNextConfiguration { StringPrefix = SettingsHelper.GetValue("Prefix"), EnableDms = false, EnableMentionPrefix = false }; var vcfg = new VoiceNextConfiguration { VoiceApplication = VoiceApplication.Music, EnableIncoming = true }; AppState.CommandsNextModule = Client.UseCommandsNext(ccfg); AppState.CommandsNextModule.RegisterCommands <InternalCommands>(); AssemblyHelper.GetAssemblies().ForEach(o => AppState.CommandsNextModule.RegisterCommands(o)); AppState.VoiceNextClient = Client.UseVoiceNext(vcfg); } catch (Exception ex) { AppState.Logger.WriteLog(Enums.Enums.LogLevel.FATAL, "Could not start Service", ex); } }
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, LogLevel = LogLevel.Debug, Token = this.Config.Token, TokenType = this.Config.UseUserToken ? TokenType.User : TokenType.Bot, UseInternalLogHandler = false, ShardId = shardid, ShardCount = this.Config.ShardCount, //GatewayCompressionLevel = GatewayCompressionLevel.Stream, MessageCacheSize = 2048, AutomaticGuildSync = !this.Config.UseUserToken, DateTimeFormat = "dd-MM-yyyy HH:mm:ss zzz" }; Discord = new DiscordClient(dcfg); // events Discord.DebugLogger.LogMessageReceived += this.DebugLogger_LogMessageReceived; Discord.Ready += this.Discord_Ready; Discord.GuildAvailable += this.Discord_GuildAvailable; Discord.ClientErrored += this.Discord_ClientErrored; Discord.SocketErrored += this.Discord_SocketError; Discord.GuildCreated += this.Discord_GuildCreated; Discord.VoiceStateUpdated += this.Discord_VoiceStateUpdated; Discord.GuildDownloadCompleted += this.Discord_GuildDownloadCompleted; Discord.GuildUpdated += this.Discord_GuildUpdated; Discord.ChannelDeleted += this.Discord_ChannelDeleted; // voice config and the voice service itself var vcfg = new VoiceNextConfiguration { VoiceApplication = VoiceNext.Codec.VoiceApplication.Music, EnableIncoming = false }; this.VoiceService = this.Discord.UseVoiceNext(vcfg); // build a dependency collection for commandsnext var depco = new ServiceCollection() .AddSingleton(new TestBotService()) .AddScoped <TestBotScopedService>(); // commandsnext config and the commandsnext service itself var cncfg = new CommandsNextConfiguration { StringPrefixes = this.Config.CommandPrefixes, //PrefixResolver = msg => //{ // if (TestBotCommands.PrefixSettings.ContainsKey(msg.Channel.Id) && TestBotCommands.PrefixSettings.TryGetValue(msg.Channel.Id, out var pfix)) // return Task.FromResult(msg.GetStringPrefixLength(pfix)); // return Task.FromResult(-1); //}, EnableDms = true, EnableMentionPrefix = true, CaseSensitive = false, Services = depco.BuildServiceProvider(true), IgnoreExtraArguments = false, UseDefaultCommandHandler = true, //DefaultHelpChecks = new List<CheckBaseAttribute>() { new RequireOwnerAttribute() } }; this.CommandsNextService = 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>(); // hook command handler //this.Discord.MessageCreated += this.Discord_MessageCreated; // interactivity service var icfg = new InteractivityConfiguration() { PaginationBehavior = TimeoutBehaviour.DeleteMessage, PaginationTimeout = TimeSpan.FromSeconds(30), Timeout = TimeSpan.FromSeconds(30) }; this.InteractivityService = Discord.UseInteractivity(icfg); this.LavalinkService = Discord.UseLavalink(); }
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, LogLevel = LogLevel.Debug, Token = this.Config.Token, TokenType = TokenType.Bot, UseInternalLogHandler = false, ShardId = shardid, ShardCount = this.Config.ShardCount, MessageCacheSize = 2048, DateTimeFormat = "dd-MM-yyyy HH:mm:ss zzz" }; Discord = new DiscordClient(dcfg); // events Discord.DebugLogger.LogMessageReceived += this.DebugLogger_LogMessageReceived; Discord.Ready += this.Discord_Ready; Discord.GuildAvailable += this.Discord_GuildAvailable; Discord.ClientErrored += this.Discord_ClientErrored; Discord.SocketErrored += this.Discord_SocketError; Discord.GuildCreated += this.Discord_GuildCreated; Discord.VoiceStateUpdated += this.Discord_VoiceStateUpdated; Discord.GuildDownloadCompleted += this.Discord_GuildDownloadCompleted; Discord.GuildUpdated += this.Discord_GuildUpdated; Discord.ChannelDeleted += this.Discord_ChannelDeleted; // 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, }; this.CommandsNextService = 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(3) }; this.InteractivityService = Discord.UseInteractivity(icfg); this.LavalinkService = Discord.UseLavalink(); }
public static void addcommands(DiscordClient p_discord) { p_discord.UseCommands(new CommandConfig { Prefix = "!", SelfBot = false, }); UserRepository userrepo = new UserRepository(new UserSQLContext()); MessageRepository msgrepo = new MessageRepository(new MessageSQLContext()); p_discord.AddCommand("hello", async e => { string[] msg = e.Message.Content.Split(' '); //if msg array contains more then 1 arrayobject then.. if (msg.Length > 1 && msg[1].Length >= 3) { bool ChannelContainsUser = false; List <DiscordUser> members = new List <DiscordUser>(); //check if member is in the current 'guild' foreach (DiscordMember dm in e.Guild.Members) { //check if msg[1] containst a part of the user if (dm.User.Username.ToUpper().Contains(msg[1].ToUpper())) { if (dm.User.Username.ToUpper() == msg[1].ToUpper()) { ChannelContainsUser = true; await e.Message.Respond($"{e.Message.Author.Username } says hello to <@{dm.User.ID}> "); break; } members.Add(dm.User); } if (members.Count > 1 && !ChannelContainsUser) { await e.Message.Respond($"more then 1 user with those characters in his name"); ChannelContainsUser = true; break; } } if (members.Count == 1) { ChannelContainsUser = true; await e.Message.Respond($"{e.Message.Author.Username } says hello to <@{members[0].ID}> "); } else if (!ChannelContainsUser) { await e.Message.Respond("That user is not in the current channel"); } } else { await e.Message.Respond($"Hello, {e.Message.Author.Mention}!"); } }); p_discord.AddCommand("reken", async e => { string[] msg = e.Message.Content.Split(' '); try { double num1 = Convert.ToDouble(msg[1]); double num2 = Convert.ToDouble(msg[3]); double num3 = 1; if (msg.Length > 4) { num3 = Convert.ToDouble(msg[4]); } switch (msg[2]) { case "+": await e.Message.Respond(num1.ToString() + msg[2] + num2.ToString() + '=' + (num1 + num2).ToString()); break; case "-": await e.Message.Respond(num1.ToString() + msg[2] + num2.ToString() + '=' + (num1 - num2).ToString()); break; case "*": case "x": await e.Message.Respond(num1.ToString() + msg[2] + num2.ToString() + '=' + (num1 * num2).ToString()); break; case "/": await e.Message.Respond(num1.ToString() + msg[2] + num2.ToString() + '=' + (num1 / num2).ToString()); break; case "**": case "^": await e.Message.Respond(num1.ToString() + msg[2] + num2.ToString() + '=' + Math.Pow(num1, num2).ToString()); break; case "^^": await e.Message.Respond(num1.ToString() + msg[2] + num2.ToString() + '=' + Math.Pow(Math.Pow(num1, num2), num3).ToString()); break; case "%": await e.Message.Respond(num1.ToString() + msg[2] + num2.ToString() + '=' + (num1 % num2).ToString()); break; case ">": case "<": case "==": case "!=": await e.Message.Respond(msg[1] + " " + msg[2] + " " + msg[3] + " " + "= " + Operator(msg[2], num1, num2).ToString()); break; default: break; } } catch (Exception exc) { await e.Message.Respond(exc.Message); } }); p_discord.AddCommand("join", async e => { try { var vcfg = new VoiceNextConfiguration { VoiceApplication = DSharpPlus.VoiceNext.Codec.VoiceApplication.Music }; VoiceService = p_discord.UseVoiceNext(vcfg); await VoiceService.ConnectAsync(await p_discord.GetChannelByID(272324215439491072)); Console.WriteLine("Joined voice channel"); } catch (Exception exc) { Console.WriteLine(exc.Message); } }); p_discord.AddCommand("dc", async e => { try { DiscordGuild guild = await p_discord.GetGuild(e.Channel.GuildID); VoiceService.GetConnection(guild).Disconnect(); VoiceService.GetConnection(guild).Dispose(); } catch (Exception exc) { Console.WriteLine(exc.Message); } }); p_discord.AddCommand("god", async e => { if (e.Message.Author.ID == 261216517910167554) { await e.Message.Respond("AND THE REAL C#GOD IS....\n" + e.Message.Author.Username); } else { await e.Message.Respond("you're not teh real c#god."); } }); p_discord.AddCommand("kkk", async e => { await e.Message.Respond($"WHITE POWER, RIGHT { e.Message.Author.Username }?"); }); p_discord.AddCommand("help", async e => { string prefix = "!"; await e.Message.Respond($"currently available commands are: \n{prefix}hello <username> \n{prefix}reken 'nummer' 'operator' 'nummer' \n{prefix}god to see if you are a c# god\n{prefix}karma @username to give a user karma!\n" + $"{prefix}dice 'minimumnumber' 'maximumnumber' (without the quotes) to generate a random number. {prefix}dice will automatically pick a number between 1 and 100.\n" + $"\n\nThis bot also functions as Robot9000. This means that the bot will mute you if you post duplicate content that already has been posted in this server.\n" + "The amount of time you get muted depends on the amount of punishments you already had."); }); p_discord.AddCommand("666", async e => { await e.Message.Respond("HAIL SATAN " + e.Message.Author.Username); }); p_discord.AddCommand("blm", async e => { await e.Message.Respond("BLACK HAS NO POWER, RIGHT " + e.Message.Author.Username + "?"); }); p_discord.AddCommand("play", async e => { try { DiscordGuild guild = await p_discord.GetGuild(e.Channel.GuildID); var rand = new Random(); var bytes = new byte[32000]; rand.NextBytes(bytes); await VoiceService.GetConnection(guild).SendAsync(bytes, 517, 16); Console.Write("i just played something!"); } catch (Exception exc) { Console.WriteLine(exc.Message); } }); p_discord.AddCommand("karma", async e => { string[] msg = e.Message.Content.Split(' '); List <DiscordUser> users = e.Message.Mentions; if (users.Count == 1) { if (users[0].ID != e.Message.Author.ID) { int karma = AddKarma(users[0].ID); await e.Message.Respond($"{users[0].Username} gained 1 karma!\n{users[0].Username} now has {karma} karma"); } else { await e.Message.Respond($"You just lost 1 karma"); } } else if (users.Count > 1) { await e.Message.Respond($"Please only mention 1 user :)"); } else { await e.Message.Respond($"You have to at least mention 1 user"); } }); p_discord.AddCommand("dice", async e => { string[] msg = e.Message.Content.Split(' '); if (msg.Length > 1) { int random = Dice(Convert.ToInt32(msg[1]), Convert.ToInt32(msg[2])); await e.Message.Respond(random.ToString()); } else if (msg.Length == 1) { int random = Dice(1, 101); await e.Message.Respond(random.ToString()); } else { await e.Message.Respond("Please use 2 parameters divided by a space"); } }); p_discord.AddCommand("unmute", async e => { await Task.Delay(0); if (e.Message.Author.ID == 261216517910167554 || e.Message.Author.ID == 239471183475638272) { if (e.Message.Mentions.Count > 0) { foreach (DiscordUser user in e.Message.Mentions) { new UserRepository(new UserSQLContext()).Unmute(user.ID); await e.Message.Respond($"{e.Message.Author.Username } unmuted <@{user.ID}> "); } } else { await e.Message.Respond($"Please mention the user(s) you want to unmute!"); } } else { await e.Message.Respond($"You ar not permitted to unmute users!"); } }); p_discord.AddCommand("mutereset", async e => { if (e.Message.Author.ID == 261216517910167554 || e.Message.Author.ID == 239471183475638272) { if (userrepo.MuteCountreset()) { userrepo.MuteReset(); await e.Message.Respond("Robot9000 mutes have been reset!"); } else { await e.Message.Respond("Oops! looks like something went wrong. Please contact Mivo90"); } } else { await e.Message.Respond("I'm sorry, I can not let you do that."); } }); p_discord.AddCommand("messagereset", async e => { if (e.Message.Author.ID == 261216517910167554 || e.Message.Author.ID == 239471183475638272) { if (msgrepo.ResetMessages()) { await e.Message.Respond("Robot9000 messages have been reset!"); } else { await e.Message.Respond("Oops, couldn't reset the messages. Please contact Mivo90"); } } else { await e.Message.Respond("Nice try."); } }); }
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.Debug, 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 }; Discord = new DiscordClient(dcfg); // events Discord.Ready += this.Discord_Ready; Discord.GuildAvailable += this.Discord_GuildAvailable; Discord.PresenceUpdated += this.Discord_PresenceUpdated; //Discord.ClientErrored += this.Discord_ClientErrored; Discord.SocketErrored += this.Discord_SocketError; Discord.GuildCreated += this.Discord_GuildCreated; Discord.VoiceStateUpdated += this.Discord_VoiceStateUpdated; Discord.GuildDownloadCompleted += this.Discord_GuildDownloadCompleted; Discord.GuildUpdated += this.Discord_GuildUpdated; Discord.ChannelDeleted += this.Discord_ChannelDeleted; // For event timeout testing //Discord.GuildDownloadCompleted += async (s, e) => //{ // await Task.Delay(TimeSpan.FromSeconds(2)).ConfigureAwait(false); // throw new Exception("Flippin' tables"); //}; // 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, }; this.CommandsNextService = 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(3) }; this.InteractivityService = Discord.UseInteractivity(icfg); this.LavalinkService = Discord.UseLavalink(); //this.Discord.MessageCreated += async e => //{ // if (e.Message.Author.IsBot) // return; // _ = Task.Run(async () => await e.Message.RespondAsync(e.Message.Content)).ConfigureAwait(false); //}; }
public async Task RunBotAsync() { var cfg = new DiscordConfiguration { Token = "NTI4OTQ3OTA1ODYwNDY4NzU1.DxEuvw.B9u9nu-pNC5G3xrqgcXfbPIeg9E", TokenType = TokenType.Bot, AutoReconnect = true, LogLevel = LogLevel.Debug, UseInternalLogHandler = true }; // then we want to instantiate our client this.Client = new DiscordClient(cfg); // If you are on Windows 7 and using .NETFX, install // DSharpPlus.WebSocket.WebSocket4Net from NuGet, // add appropriate usings, and uncomment the following // line //this.Client.SetWebSocketClient<WebSocket4NetClient>(); // If you are on Windows 7 and using .NET Core, install // DSharpPlus.WebSocket.WebSocket4NetCore from NuGet, // add appropriate usings, and uncomment the following // line //this.Client.SetWebSocketClient<WebSocket4NetCoreClient>(); // If you are using Mono, install // DSharpPlus.WebSocket.WebSocketSharp from NuGet, // add appropriate usings, and uncomment the following // line //this.Client.SetWebSocketClient<WebSocketSharpClient>(); // if using any alternate socket client implementations, // remember to add the following to the top of this file: //using DSharpPlus.Net.WebSocket; // next, let's hook some events, so we know // what's going on this.Client.Ready += this.Client_Ready; this.Client.GuildAvailable += this.Client_GuildAvailable; this.Client.ClientErrored += this.Client_ClientError; // up next, let's set up our commands var ccfg = new CommandsNextConfiguration { // let's use the string prefix defined in config.json StringPrefix = "!", // enable responding in direct messages EnableDms = true, // enable mentioning the bot as a command prefix EnableMentionPrefix = true }; // and hook them up this.Commands = this.Client.UseCommandsNext(ccfg); // let's hook some command events, so we know what's // going on this.Commands.CommandExecuted += this.Commands_CommandExecuted; this.Commands.CommandErrored += this.Commands_CommandErrored; this.Client.MessageCreated += this.Handle_Message; // up next, let's register our commands // but with Reflection \^^/ //i added a comment foreach (var item in Assembly.GetExecutingAssembly().GetTypes().Where(x => x.GetInterfaces().Contains(typeof(IWillCommand)))) { var methodtoInvoke = typeof(CommandsNextModule).GetMethod("RegisterCommands", Type.EmptyTypes); var method = methodtoInvoke.MakeGenericMethod(item); method.Invoke(this.Commands, null); } // let's set up voice var vcfg = new VoiceNextConfiguration { VoiceApplication = VoiceApplication.Music }; // and let's enable it this.Voice = this.Client.UseVoiceNext(vcfg); // finally, let's connect and log in await this.Client.ConnectAsync(); // for this example you will need to read the // VoiceNext setup guide, and include ffmpeg. // and this is to prevent premature quitting await Task.Delay(-1); }
private async Task MainAsync() { // getting versions and assembly info SetBotVersionInfo(); // init log channels _logChannels = new List <DiscordChannel>(); _lastLogChWrite = File.GetLastWriteTime("logchannels.txt"); string json = await FileHandler.ReadJsonConfig(); if (json.Length == 0) { return; } if (json == "default") { Console.ForegroundColor = ConsoleColor.DarkGreen; Console.WriteLine("Created default config file.\n" + "Now you need to get your discord bot token " + "and put it in config.json file.\n" + "Also make sure you set other parameters."); Console.ResetColor(); return; } // setting up client var cfgjson = JsonSerializer.Deserialize <ConfigJson>(json); if (cfgjson == null) { return; } var cfg = new DiscordConfiguration { Token = cfgjson.Token, TokenType = TokenType.Bot, AutoReconnect = true, MinimumLogLevel = RuntimeInfo == "Debug" ? LogLevel.Debug : LogLevel.Information, MessageCacheSize = 2048, LogTimestampFormat = "dd-MM-yyyy HH:mm:ss zzz" }; // client init and event hooks _discord = new DiscordClient(cfg); _discord.Ready += Discord_Ready; _discord.GuildAvailable += Discord_GuildAvailable; _discord.GuildUnavailable += Discord_GuildUnavailable; _discord.GuildCreated += Discord_GuildCreated; _discord.GuildDeleted += Discord_GuildDeleted; _discord.ChannelDeleted += Discord_ChannelDeleted; _discord.DmChannelDeleted += Discord_DmChannelDeleted; _discord.GuildDownloadCompleted += Discord_GuildDownloadCompleted; _discord.ClientErrored += Discord_ClientErrored; _discord.SocketClosed += Discord_SocketClosed; _discord.Resumed += Discord_Resumed; _discord.Heartbeated += Discord_Heartbeated; // setting up interactivity var intcfg = new InteractivityConfiguration { Timeout = TimeSpan.FromMinutes(cfgjson.ActTimeout), PaginationDeletion = PaginationDeletion.DeleteMessage, PollBehaviour = PollBehaviour.KeepEmojis }; _discord.UseInteractivity(intcfg); // setting up commands var cmdcfg = new CommandsNextConfiguration { StringPrefixes = new List <string> { cfgjson.CommandPrefix }, EnableDms = cfgjson.DmsEnabled, EnableMentionPrefix = cfgjson.MentionEnabled, CaseSensitive = cfgjson.CaseSensitive, EnableDefaultHelp = true }; // commands hooks and register _commands = _discord.UseCommandsNext(cmdcfg); _commands.CommandExecuted += Commands_CommandExecuted; _commands.CommandErrored += Commands_CommandErrored; _commands.RegisterCommands <Commands.Commands>(); _commands.RegisterCommands <LeetCommands>(); _commands.RegisterCommands <Interactivities.Interactivities>(); _commands.RegisterCommands <Administrative>(); _commands.RegisterCommands <Cats>(); _commands.RegisterCommands <DiceRolling>(); _commands.RegisterCommands <CryptoAes>(); _commands.RegisterCommands <CryptoRsa>(); _commands.RegisterCommands <MathCommands>(); _commands.RegisterCommands <StatusCommands>(); _commands.RegisterCommands <VoiceCommands>(); // adding math converter for custom type and name var mathopscvrt = new MathOperationConverter(); _commands.RegisterConverter(mathopscvrt); _commands.RegisterUserFriendlyTypeName <MathOperation>("operator"); // setting up and enabling voice var vcfg = new VoiceNextConfiguration { AudioFormat = AudioFormat.Default, EnableIncoming = false }; _discord.UseVoiceNext(vcfg); // setting custom help formatter _commands.SetHelpFormatter <HelpFormatter>(); // init twitch live and youtube video monitors _ttvApIclid = cfgjson.TwitchApiClid; _ttvApIsecret = cfgjson.TwitchApiSecret; _ytApIkey = cfgjson.YoutubeApiKey; _tlm = new TwitchLiveMonitor(); _yvm = new YoutubeVideoMonitor(); // getting aes and rsa keys from config AesKey = cfgjson.AesKey; AesIv = cfgjson.AesIv; RsaPublicKey = cfgjson.RsaPublicKey; RsaPrivateKey = cfgjson.RsaPrivateKey; // connecting discord try { await _discord.ConnectAsync(); } catch (Exception e) { _discord.Logger.LogCritical($"{e.Message}"); return; } await Task.Delay(-1); }
static async Task MainAsync(string[] args) { /* * var http = (HttpWebRequest)WebRequest.Create(new Uri("https://discordapp.com/api/v6/auth/login")); * http.Accept = "application/json"; * http.ContentType = "application/json"; * http.Method = "POST"; * string parsedContent = Newtonsoft.Json.JsonSerializer. * ASCIIEncoding encoding = new ASCIIEncoding(); * Byte[] bytes = encoding.GetBytes(parsedContent); * Stream newStream = http.GetRequestStream(); * newStream.Write(bytes, 0, bytes.Length); * newStream.Close(); * var response = http.GetResponse(); * * var stream = response.GetResponseStream(); * var srr = new StreamReader(stream); * var content = srr.ReadToEnd(); * * using (var wb = new WebClient()) * { * var data = new NameValueCollection(); * data["email"] = "email"; * data["password"] = "******"; * wb.Headers.Add("Content-Type", "application/x-www-form-urlencoded"); * var res = wb.UploadValues("https://discordapp.com/api/v6/auth/login", data); * response = Encoding.Default.GetString(res); * } */ var json = ""; using (var fs = File.OpenRead("config.json")) using (var sr = new StreamReader(fs, new UTF8Encoding(false))) json = await sr.ReadToEndAsync(); var cfgjson = Newtonsoft.Json.JsonConvert.DeserializeObject <ConfigJson>(json); var conf = new DiscordConfiguration { //Token = cfgjson.Token, //TokenType = TokenType.Bot, Token = cfgjson.Token, TokenType = TokenType.User, UseInternalLogHandler = true, LogLevel = LogLevel.Debug, AutoReconnect = true, }; try { discord = new DiscordClient(conf); } catch (Exception e) { Console.Write(e); } var commands = discord.UseCommandsNext(new CommandsNextConfiguration { StringPrefix = cfgjson.CommandPrefix, EnableDms = false, EnableMentionPrefix = true }); var vcfg = new VoiceNextConfiguration { VoiceApplication = VoiceApplication.Music }; var voice = discord.UseVoiceNext(vcfg); discord.MessageCreated += async ev => { if (checkUser(ev)) { try { await analyzeMessage(ev); } catch (Exception ex) { Console.Write(ex); } } }; commands.RegisterCommands <MartinCommands>(); await discord.ConnectAsync(); await Task.Delay(-1); }
public async Task RunBotAsync() { // first, let's load our configuration file string json; using (var fs = File.OpenRead("config.json")) using (var sr = new StreamReader(fs, new UTF8Encoding(false))) json = await sr.ReadToEndAsync(); // next, let's load the values from that file // to our client's configuration var cfgjson = JsonConvert.DeserializeObject <ConfigJson>(json); var cfg = new DiscordConfiguration { Token = cfgjson.Token, TokenType = TokenType.Bot, AutoReconnect = true, LogLevel = LogLevel.Debug, UseInternalLogHandler = true }; // then we want to instantiate our client Client = new DiscordClient(cfg); // If you are on Windows 7 and using .NETFX, install // DSharpPlus.WebSocket.WebSocket4Net from NuGet, // add appropriate usings, and uncomment the following // line //this.Client.SetWebSocketClient<WebSocket4NetClient>(); // If you are on Windows 7 and using .NET Core, install // DSharpPlus.WebSocket.WebSocket4NetCore from NuGet, // add appropriate usings, and uncomment the following // line //this.Client.SetWebSocketClient<WebSocket4NetCoreClient>(); // If you are using Mono, install // DSharpPlus.WebSocket.WebSocketSharp from NuGet, // add appropriate usings, and uncomment the following // line //this.Client.SetWebSocketClient<WebSocketSharpClient>(); // if using any alternate socket client implementations, // remember to add the following to the top of this file: //using DSharpPlus.Net.WebSocket; // next, let's hook some events, so we know // what's going on Client.Ready += Client_Ready; Client.GuildAvailable += Client_GuildAvailable; Client.ClientErrored += Client_ClientError; // up next, let's set up our commands var ccfg = new CommandsNextConfiguration { // let's use the string prefix defined in config.json StringPrefixes = new[] { cfgjson.CommandPrefix }, // enable responding in direct messages EnableDms = true, // enable mentioning the bot as a command prefix EnableMentionPrefix = true }; // and hook them up Commands = Client.UseCommandsNext(ccfg); // let's hook some command events, so we know what's // going on Commands.CommandExecuted += Commands_CommandExecuted; Commands.CommandErrored += Commands_CommandErrored; // up next, let's register our commands Commands.RegisterCommands <ExampleInteractiveCommands>(); // let's set up voice var vcfg = new VoiceNextConfiguration { VoiceApplication = VoiceApplication.Music }; // and let's enable it Voice = Client.UseVoiceNext(vcfg); // finally, let's connect and log in await Client.ConnectAsync(); // when the bot is running, try doing <prefix>help // to see the list of registered commands, and // <prefix>help <command> to see help about specific // command. // and this is to prevent premature quitting await Task.Delay(-1); }
static async Task MainAsync(string[] args) { // Create service collection and configure our services var serviceProvider = new ServiceCollection() .AddSingleton <IKarvisConfigurationService>(new KarvisConfigurationService()) .AddSingleton <IProvideAudioState>(new AudioStateProvider()) .BuildServiceProvider(); karvisConfiguration = serviceProvider.GetService <IKarvisConfigurationService>().Configuration; discord = new DiscordClient(new DSharpPlus.DiscordConfiguration() { Token = karvisConfiguration.DiscordConfiguration.Token, TokenType = TokenType.Bot, UseInternalLogHandler = true, LogLevel = LogLevel.Debug, AutoReconnect = true }); var audioConfig = new VoiceNextConfiguration(); audioConfig.AudioFormat = new AudioFormat(48000, 2, VoiceApplication.Music); audioConfig.EnableIncoming = true; voice = discord.UseVoiceNext(audioConfig); discord.MessageCreated += async e => { if (e.Message.Content.ToLower().StartsWith("ping")) { await e.Message.RespondAsync("pong!"); } }; commands = discord.UseCommandsNext(new CommandsNextConfiguration { StringPrefixes = new List <string>() { ";;", "->" }, EnableDms = false, // required for UseVoiceNext? Services = serviceProvider }); commands.RegisterCommands <CommandsModule>(); commands.RegisterCommands <LavalinkCommandsModule>(); commands.RegisterCommands <AzureCommandsModule>(); commands.RegisterCommands <GoogleCommandsModule>(); interactivity = discord.UseInteractivity(new InteractivityConfiguration { }); lavalink = discord.UseLavalink(); discord.Ready += Client_Ready; discord.GuildAvailable += Client_GuildAvailable; discord.ClientErrored += Client_ClientError; await discord.ConnectAsync(); await Task.Delay(-1); // infinite wait to prevent exit }
public static async Task MainAsync(string[] args) { var filePath = "./Data/Token.json"; var jsonData = System.IO.File.ReadAllText(filePath); Token _Token = JsonConvert.DeserializeObject <Token>(jsonData); discord = new DiscordClient(new DiscordConfiguration { Token = _Token.token, TokenType = TokenType.Bot, UseInternalLogHandler = true, LogLevel = LogLevel.Info }); discord.MessageCreated += async e => { if (e.Message.Content.ToLower().Equals("lemme smash")) { await e.Message.RespondAsync("no ron"); } }; discord.UseInteractivity(new InteractivityConfiguration { PaginationBehaviour = DSharpPlus.Interactivity.Enums.PaginationBehaviour.Default, Timeout = TimeSpan.FromMinutes(2) }); List <string> prefixes = new List <string>() { "|" }; commands = discord.UseCommandsNext(new CommandsNextConfiguration { StringPrefixes = prefixes, EnableDms = true, EnableMentionPrefix = true }); var vcfg = new VoiceNextConfiguration { AudioFormat = AudioFormat.Default, }; var game = new DiscordActivity() { Name = "Type |help for help!", ActivityType = ActivityType.Playing, }; commands.RegisterCommands <Commands>(); commands.RegisterCommands <ServerCommands>(); commands.RegisterCommands <GBFCommands>(); commands.RegisterCommands <LeagueCommands>(); await discord.ConnectAsync(); discord.Ready += async e => { await discord.UpdateStatusAsync(game); DisplayGuildCount(); ReadyChecker = true; }; #pragma warning disable CS1998 discord.Heartbeated += async e => { if (ReadyChecker == true) { DisplayGuildCount(); } }; #pragma warning restore CS1998 await Task.Delay(-1); }
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, LogLevel = LogLevel.Debug, Token = this.Config.Token, TokenType = this.Config.UseUserToken ? TokenType.User : TokenType.Bot, UseInternalLogHandler = false, ShardId = shardid, ShardCount = this.Config.ShardCount, EnableCompression = true, MessageCacheSize = 50, AutomaticGuildSync = !this.Config.UseUserToken, DateTimeFormat = "dd-MM-yyyy HH:mm:ss zzz" }; Discord = new DiscordClient(dcfg); // events Discord.DebugLogger.LogMessageReceived += this.DebugLogger_LogMessageReceived; Discord.Ready += this.Discord_Ready; Discord.GuildAvailable += this.Discord_GuildAvailable; Discord.GuildBanAdded += this.Discord_GuildBanAdd; Discord.MessageCreated += this.Discord_MessageCreated; Discord.MessageReactionAdded += this.Discord_MessageReactionAdd; Discord.MessageReactionsCleared += this.Discord_MessageReactionRemoveAll; Discord.PresenceUpdated += this.Discord_PresenceUpdate; Discord.ClientErrored += this.Discord_ClientErrored; Discord.SocketErrored += this.Discord_SocketError; Discord.GuildCreated += this.Discord_GuildCreated; // voice config and the voice service itself var vcfg = new VoiceNextConfiguration { VoiceApplication = VoiceNext.Codec.VoiceApplication.Music, EnableIncoming = false }; this.VoiceService = this.Discord.UseVoiceNext(vcfg); // build a dependency collection for commandsnext var depco = new DependencyCollectionBuilder(); depco.AddInstance("This is a dependency string."); depco.Add <TestDependency>(); // commandsnext config and the commandsnext service itself var cncfg = new CommandsNextConfiguration { StringPrefix = this.Config.CommandPrefix, CustomPrefixPredicate = msg => { if (TestBotNextCommands.Prefixes.ContainsKey(msg.Channel.Id) && TestBotNextCommands.Prefixes.TryGetValue(msg.Channel.Id, out var pfix)) { return(Task.FromResult(msg.GetStringPrefixLength(pfix))); } return(Task.FromResult(-1)); }, EnableDms = true, EnableMentionPrefix = true, CaseSensitive = true, Dependencies = depco.Build(), SelfBot = this.Config.UseUserToken, IgnoreExtraArguments = false //DefaultHelpChecks = new List<CheckBaseAttribute>() { new RequireOwnerAttribute() } }; this.CommandsNextService = Discord.UseCommandsNext(cncfg); this.CommandsNextService.CommandErrored += this.CommandsNextService_CommandErrored; this.CommandsNextService.CommandExecuted += this.CommandsNextService_CommandExecuted; //this.CommandsNextService.RegisterCommands<TestBotCommands>(); //this.CommandsNextService.RegisterCommands<TestBotNextCommands>(); //this.CommandsNextService.RegisterCommands<TestBotEvalCommands>(); //this.CommandsNextService.RegisterCommands<TestBotDependentCommands>(); //this.CommandsNextService.RegisterCommands<TestBotGroupInheritedChecksCommands>(); this.CommandsNextService.RegisterCommands(typeof(TestBot).GetTypeInfo().Assembly); this.CommandsNextService.SetHelpFormatter <TestBotHelpFormatter>(); // interactivity service var icfg = new InteractivityConfiguration() { PaginationBehaviour = TimeoutBehaviour.Delete, PaginationTimeout = TimeSpan.FromSeconds(30), Timeout = TimeSpan.FromSeconds(30) }; this.InteractivityService = Discord.UseInteractivity(icfg); }
public TestBot(TestBotConfig cfg) { // global bot config this.Config = cfg; // discord instance config and the instance itself var dcfg = new DiscordConfig { AutoReconnect = true, DiscordBranch = Branch.Stable, LargeThreshold = 250, // Use unnecessary instead of debug for more verbosity //LogLevel = LogLevel.Unnecessary, LogLevel = LogLevel.Debug, Token = this.Config.Token, TokenType = TokenType.Bot, UseInternalLogHandler = false, }; this.Discord = new DiscordClient(dcfg); // events this.Discord.DebugLogger.LogMessageReceived += this.DebugLogger_LogMessageReceived; this.Discord.Ready += this.Discord_Ready; this.Discord.GuildAvailable += this.Discord_GuildAvailable; this.Discord.GuildBanAdd += this.Discord_GuildBanAdd; this.Discord.MessageCreated += this.Discord_MessageCreated; this.Discord.MessageReactionAdd += this.Discord_MessageReactionAdd; this.Discord.MessageReactionRemoveAll += this.Discord_MessageReactionRemoveAll; this.Discord.PresenceUpdate += this.Discord_PresenceUpdate; // command config and the command service itself this.Commands = new TestBotCommands(); var ccfg = new CommandConfig { Prefix = this.Config.CommandPrefix, SelfBot = false }; this.CommandService = this.Discord.UseCommands(ccfg); this.CommandService.CommandError += this.CommandService_CommandError; // register all commands dynamically var t = new[] { typeof(TestBotCommands), typeof(Task), typeof(CommandEventArgs) }; var cm = t[0].GetMethods(BindingFlags.Public | BindingFlags.Instance) .Where(xm => this.IsCommandMethod(xm, t[1], t[2])); var expr_inst = Expression.Constant(this.Commands); var expr_arg0 = Expression.Parameter(t[2]); foreach (var xm in cm) { var expr_call = Expression.Call(expr_inst, xm, expr_arg0); var expr_anon = Expression.Lambda <Func <CommandEventArgs, Task> >(expr_call, expr_arg0); var cmcall = expr_anon.Compile(); this.Discord.AddCommand(xm.Name.ToLower(), cmcall); this.Discord.DebugLogger.LogMessage(LogLevel.Info, "DSPlus Test", $"Command {xm.Name.ToLower()} registered", DateTime.Now); } // voice config and the voice service itself var vcfg = new VoiceNextConfiguration { VoiceApplication = VoiceNext.Codec.VoiceApplication.Music }; this.VoiceService = this.Discord.UseVoiceNext(vcfg); }
//main async task public async Task startBotAsync() { //loading configuration from json var json = ""; using (var file = File.OpenRead("config.json")) using (var sr = new StreamReader(file, new UTF8Encoding(false))) json = await sr.ReadToEndAsync(); //load values from config var configjson = JsonConvert.DeserializeObject <ConfigJson>(json); var config = new DiscordConfiguration { Token = configjson.Token, TokenType = TokenType.Bot, AutoReconnect = true, LogLevel = LogLevel.Info, UseInternalLogHandler = true }; //instantiate the bot this.bot = new DiscordClient(config); //hook events to the bot this.bot.Ready += this.botReady; this.bot.Ready += this.botStatusAsync; this.bot.GuildAvailable += this.botGuildAvailable; this.bot.ClientErrored += this.botErrorHandler; //command setup var commandConfig = new CommandsNextConfiguration { //use prefix from config StringPrefixes = new[] { configjson.CommandPrefix }, //enable mentioning the bot as a prefix EnableMentionPrefix = true }; //hook to bot this.Commands = this.bot.UseCommandsNext(commandConfig); //hook command events for debugging this.Commands.CommandExecuted += this.commandsExecuted; this.Commands.CommandErrored += this.commandsError; //register commands this.Commands.RegisterCommands <zeroTwoCommandsUngroupped>(); //this.Commands.RegisterCommands<zeroTwoCommandsInteractive>(); this.Commands.RegisterCommands <zeroTwoCommandsVoice>(); var voiceConfig = new VoiceNextConfiguration { AudioFormat = AudioFormat.Default }; this.Voice = this.bot.UseVoiceNext(voiceConfig); //connect and log in await this.bot.ConnectAsync(); //when bot is running, <prefix>help will show command list, <prefix>help <command> will show help abbout the command //this is to prevent premature quitting await Task.Delay(-1); }
public async Task RunBotAsync() { //Reads the config file var json = ""; using (var fs = File.OpenRead("config.json")) using (var sr = new StreamReader(fs, new UTF8Encoding(false))) json = await sr.ReadToEndAsync(); //reads value from the config //to our client config var cfgjson = JsonConvert.DeserializeObject <ConfigJson>(json); var cfg = new DiscordConfiguration { Token = cfgjson.Token, TokenType = TokenType.Bot, AutoReconnect = true, LogLevel = LogLevel.Debug, UseInternalLogHandler = true }; discord = new DiscordClient(cfg); discord.SetWebSocketClient <WebSocket4NetClient>(); //hooks some events, so we know //whats going on discord.Ready += Client_Ready; discord.GuildAvailable += Client_GuildAvailable; discord.ClientErrored += Client_ClientError; var ccfg = new CommandsNextConfiguration { StringPrefix = "fulp", CaseSensitive = false, EnableDms = true, EnableMentionPrefix = true }; commands = discord.UseCommandsNext(ccfg); discord.UseInteractivity(new InteractivityConfiguration { PaginationBehaviour = TimeoutBehaviour.Ignore, PaginationTimeout = TimeSpan.FromMinutes(5), Timeout = TimeSpan.FromMinutes(2) }); discord.MessageCreated += async e => { if (e.Message.Content.ToLower().StartsWith("are we talking about tom fulp")) { await e.Message.RespondAsync("I **LOVE** talking about Tom Fulp"); } if ((e.Message.Content.ToLower().StartsWith("hi") || e.Message.Content.ToLower().StartsWith("hey") || e.Message.Content.ToLower().StartsWith("heya") || e.Message.Content.ToLower().StartsWith("sup") || e.Message.Content.ToLower().StartsWith("yo") || e.Message.Content.ToLower().StartsWith("hello")) && ( e.Message.Content.ToLower().EndsWith("tom") || e.Message.Content.ToLower().EndsWith("fulp") || e.Message.Content.ToLower().EndsWith("tom fulp") || e.Message.Content.ToLower().EndsWith("fulperino") || e.Message.Content.ToLower().EndsWith("fulpster") || e.Message.Content.ToLower().EndsWith("fulpo"))) { await e.Message.RespondAsync("Hi friend!"); } if (e.Message.Content.ToLower().StartsWith("good bot")) { await e.Message.RespondAsync("Yeah, I know"); } if (e.Message.Content.ToLower().StartsWith("shame on you") || e.Message.Content.ToLower().StartsWith(".r34")) { if (e.Message.Content.Length > 13 && !e.Message.Content.ToLower().StartsWith(".r34")) { await e.Message.RespondAsync("**SHAAAAAME on " + new string(e.Message.Content.Skip(13).ToArray()) + "!!!**"); } else { await e.Message.RespondAsync("**SHAAAAAME!!!**"); } } if (e.Message.Content.ToLower().StartsWith("lies lies lies")) { await e.Message.RespondAsync("yeah!\n\nhttps://www.youtube.com/watch?v=v6cn0mLJVZY"); } if (e.Message.Content.ToLower().EndsWith("loves lolis") || e.Message.Content.ToLower().StartsWith("i love lolis") || e.Message.Content.ToLower().EndsWith("love lolis") || e.Message.Content.ToLower().EndsWith("like lolis")) { await e.Message.RespondAsync("me too!"); await e.Message.RespondWithFileAsync("images/tomloveslolis.jpg"); } if (e.Message.Content.ToLower().StartsWith("i hate lolis")) { await e.Message.RespondAsync(";("); } if (e.Message.Content.ToLower().StartsWith("what's monster mashing?")) { await e.Message.RespondAsync("A good game fool, play it!\n\nhttps://www.newgrounds.com/portal/view/707498"); } if (e.Message.Content.ToLower().StartsWith("i like trains")) { await e.Message.RespondAsync("vroom\n\nhttps://www.newgrounds.com/portal/view/581989"); } }; commands.CommandExecuted += Commands_CommandExecuted; commands.CommandErrored += Commands_CommandErrored; commands.RegisterCommands <MyCommands>(); var voicecfg = new VoiceNextConfiguration { VoiceApplication = VoiceApplication.Music }; voice = discord.UseVoiceNext(voicecfg); await discord.ConnectAsync(); await Task.Delay(-1); }
public async Task RunBotAsync() { // first, let's load our configuration file var json = ""; using (var fs = File.OpenRead("config.json")) using (var sr = new StreamReader(fs, new UTF8Encoding(false))) json = await sr.ReadToEndAsync(); // next, let's load the values from that file // to our client's configuration var cfgjson = JsonConvert.DeserializeObject <ConfigJson>(json); _botID = cfgjson.Bot_ID; _serverID = cfgjson.Server_ID; var cfg = new DiscordConfiguration { Token = cfgjson.Token, TokenType = TokenType.Bot, AutoReconnect = true, LogLevel = LogLevel.Debug, UseInternalLogHandler = true }; // then we want to instantiate our client Client = new DiscordClient(cfg); // If you are on Windows 7 and using .NETFX, install // DSharpPlus.WebSocket.WebSocket4Net from NuGet, // add appropriate usings, and uncomment the following // line Client.SetWebSocketClient <WebSocket4NetClient>(); // If you are on Windows 7 and using .NET Core, install // DSharpPlus.WebSocket.WebSocket4NetCore from NuGet, // add appropriate usings, and uncomment the following // line //this.Client.SetWebSocketClient<WebSocket4NetCoreClient>(); // If you are using Mono, install // DSharpPlus.WebSocket.WebSocketSharp from NuGet, // add appropriate usings, and uncomment the following // line //this.Client.SetWebSocketClient<WebSocketSharpClient>(); // if using any alternate socket client implementations, // remember to add the following to the top of this file: //using DSharpPlus.Net.WebSocket; // next, let's hook some events, so we know // what's going on Client.Ready += Client_Ready; Client.GuildAvailable += Client_GuildAvailable; Client.ClientErrored += Client_ClientError; Client.MessageCreated += Client_MessageCreated; //Client.GuildMemberUpdated += Client_GuildMemberUpdated; Client.GuildMemberAdded += Client_GuildMemberAdded; // let's enable interactivity, and set default options Client.UseInteractivity(new InteractivityConfiguration { // default pagination behaviour to just ignore the reactions PaginationBehaviour = TimeoutBehaviour.Ignore, // default pagination timeout to 5 minutes PaginationTimeout = TimeSpan.FromMinutes(5), // default timeout for other actions to 2 minutes Timeout = TimeSpan.FromMinutes(2) }); // up next, let's set up our commands var ccfg = new CommandsNextConfiguration { // let's use the string prefix defined in config.json StringPrefix = cfgjson.CommandPrefix, // enable responding in direct messages EnableDms = true, // enable mentioning the bot as a command prefix EnableMentionPrefix = true }; // let's set up voice var vcfg = new VoiceNextConfiguration { VoiceApplication = VoiceApplication.Music }; // and hook them up Commands = Client.UseCommandsNext(ccfg); // let's hook some command events, so we know what's // going on Commands.CommandExecuted += Commands_CommandExecuted; Commands.CommandErrored += Commands_CommandErrored; // let's add a converter for a custom type and a name var mathopcvt = new MathOperationConverter(); CommandsNextUtilities.RegisterConverter(mathopcvt); CommandsNextUtilities.RegisterUserFriendlyTypeName <MathOperation>("operation"); // up next, let's register our commands Commands.RegisterCommands <ExampleUngrouppedCommands>(); Commands.RegisterCommands <ExampleGrouppedCommands>(); Commands.RegisterCommands <ExampleExecutableGroup>(); Commands.RegisterCommands <ExampleInteractiveCommands>(); Commands.RegisterCommands <ExampleVoiceCommands>(); // set up our custom help formatter Commands.SetHelpFormatter <SimpleHelpFormatter>(); // and let's enable Voice Voice = Client.UseVoiceNext(vcfg); // finally, let's connect and log in await Client.ConnectAsync(); // when the bot is running, try doing <prefix>help // to see the list of registered commands, and // <prefix>help <command> to see help about specific // command. // and this is to prevent premature quitting await Task.Delay(-1); }
public async Task RunBotAsync() { try { // load settings then we want to instantiate our client DiscordConfiguration discordConfiguration = GetConfigFromJsonSettings(); Client = new DiscordClient(discordConfiguration); } catch (InvalidConfigException ice) { Console.WriteLine(string.Format("{0}:\tCRITICAL ERROR: Problem with the Json Settings: {1}\n\nPress enter to close", DateTime.Now, ice.Message)); Console.ReadLine(); return; } // If you are on Windows 7 and using .NETFX, install // DSharpPlus.WebSocket.WebSocket4Net from NuGet, // add appropriate usings, and uncomment the following // line // this.Client.SetWebSocketClient<WebSocket4NetClient>(); // If you are on Windows 7 and using .NET Core, install // DSharpPlus.WebSocket.WebSocket4NetCore from NuGet, // add appropriate usings, and uncomment the following // line // this.Client.SetWebSocketClient<WebSocket4NetCoreClient>(); // If you are using Mono, install // DSharpPlus.WebSocket.WebSocketSharp from NuGet, // add appropriate usings, and uncomment the following // line // this.Client.SetWebSocketClient<WebSocketSharpClient>(); // if using any alternate socket client implementations, // remember to add the following to the top of this file: // using DSharpPlus.Net.WebSocket; // next, let's hook some events, so we know // what's going on Client.Ready += this.Client_Ready; Client.GuildAvailable += this.Client_GuildAvailable; Client.ClientErrored += this.Client_ClientError; Client.PresenceUpdated += Client_PresenceUpdated; Client.DebugLogger.LogMessageReceived += DebugLogger_LogMessageReceived; // up next, let's set up our commands var ccfg = new CommandsNextConfiguration { // let's use the string prefix defined in config.json StringPrefixes = new[] { configFile.CommandPrefix }, // enable responding in direct messages EnableDms = true, // enable mentioning the bot as a command prefix EnableMentionPrefix = true }; // and hook them up this.Commands = Client.UseCommandsNext(ccfg); // let's hook some command events, so we know what's // going on this.Commands.CommandExecuted += this.Commands_CommandExecuted; this.Commands.CommandErrored += this.Commands_CommandErrored; // up next, let's register our commands this.Commands.RegisterCommands <VoiceCommand>(); this.Commands.RegisterCommands <PlayAudioCommand>(); this.Commands.RegisterCommands <WormsCommand>(); this.Commands.RegisterCommands <VoiceRecognition>(); this.Commands.RegisterCommands <FuckYouCommand>(); this.Commands.RegisterCommands <CustomAudioCommand>(); this.Commands.RegisterCommands <MadWorldCommand>(); this.Commands.RegisterCommands <CustomIntroCommand>(); this.Commands.RegisterCommands <EmoteCommands>(); this.Commands.RegisterCommands <RedditCommands>(); this.Commands.SetHelpFormatter <HelpFormatter>(); //this.Client.TypingStarted += Client_TypingStarted; // let's set up voice var vcfg = new VoiceNextConfiguration { VoiceApplication = VoiceApplication.Music, EnableIncoming = false }; // and let's enable it this.Voice = Client.UseVoiceNext(vcfg); // finally, let's connect and log in await Client.ConnectAsync(); // for this example you will need to read the // VoiceNext setup guide, and include ffmpeg. RedditController.StartSubscriptionThreadsThread(); // and this is to prevent premature quitting await Task.Delay(-1); }
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); //}; }
public Core(int ParentId, int shardId) { //check if shardId assigned is < 0 if (shardId < 0) { throw new ArgumentOutOfRangeException(nameof(shardId)); } //set up credentials LogSetup.LoggerSetup(shardId); _config = new BotConfig(); _log = LogManager.GetCurrentClassLogger(); Credentials = new CoreCredentials(); _db = new DbService(Credentials); var coreConfig = new DiscordConfiguration { AutoReconnect = true, LargeThreshold = 250, LogLevel = DSharpPlus.LogLevel.Debug, Token = Credentials.Token, TokenType = Credentials.UseUserToken ? TokenType.Bot : TokenType.Bot, UseInternalLogHandler = false, ShardId = shardId, ShardCount = Credentials.TotalShards, GatewayCompressionLevel = GatewayCompressionLevel.Stream, MessageCacheSize = 50, AutomaticGuildSync = true, DateTimeFormat = "dd-MM-yyyy HH:mm:ss zzz" }; _discord = new DiscordClient(coreConfig); //attach Discord events _discord.DebugLogger.LogMessageReceived += this.DebugLogger_LogMessageReceived; _discord.Ready += this.Discord_Ready; _discord.GuildAvailable += this.Discord_GuildAvailable; _discord.MessageCreated += this.Discord_MessageCreated; _discord.ClientErrored += this.Discord_ClientErrored; _discord.SocketErrored += this.Discord_SocketError; _discord.GuildCreated += this.Discord_GuildAvailable; _discord.VoiceStateUpdated += this.Discord_VoiceStateUpdated; var voiceConfig = new VoiceNextConfiguration { VoiceApplication = DSharpPlus.VoiceNext.Codec.VoiceApplication.Music, EnableIncoming = false }; _discord.UseVoiceNext(voiceConfig); var googleService = new GoogleApiService(Credentials); //enable voice service IGoogleApiService googleApiService = new GoogleApiService(Credentials); CoreMusicService cms = new CoreMusicService(_discord, _db, Credentials, this, googleApiService); var depoBuild = new ServiceCollection(); //taken from NadeoBot's Service loading depoBuild.AddSingleton <DiscordClient>(_discord); depoBuild.AddSingleton <CoreCredentials>(Credentials); depoBuild.AddSingleton <IGoogleApiService>(googleApiService); depoBuild.AddSingleton(_db); depoBuild.AddSingleton(cms); //add dependency here using (var uow = _db.UnitOfWork) { _config = uow.BotConfig.GetOrCreate(); } //build command configuration //see Dsharpplus configuration _log.Info($"{_config.DefaultPrefix}"); var commandConfig = new CommandsNextConfiguration { StringPrefix = _config.DefaultPrefix, EnableDms = true, EnableMentionPrefix = true, CaseSensitive = true, Services = depoBuild.BuildServiceProvider(), Selfbot = Credentials.UseUserToken, IgnoreExtraArguments = false }; //attach command events this.CommandsNextService = _discord.UseCommandsNext(commandConfig); this.CommandsNextService.CommandErrored += this.CommandsNextService_CommandErrored; this.CommandsNextService.CommandExecuted += this.CommandsNextService_CommandExecuted; this.CommandsNextService.RegisterCommands(typeof(CoreCommands).GetTypeInfo().Assembly); this.CommandsNextService.SetHelpFormatter <CoreBotHelpFormatter>(); //interactive service var interConfig = new InteractivityConfiguration() { PaginationBehaviour = TimeoutBehaviour.DeleteMessage, //default paginationtimeout (30 seconds) PaginationTimeout = TimeSpan.FromSeconds(30), //timeout for current action Timeout = TimeSpan.FromMinutes(2) }; //attach interactive component this.InteractivityService = _discord.UseInteractivity(interConfig); //this.CommandsNextService.RegisterCommands<CoreInteractivityModuleCommands>(); //register commands from coreinteractivitymodulecommands //this.CommandsNextService.RegisterCommands(typeof(CoreInteractivityModuleCommands).GetTypeInfo().Assembly); }