Beispiel #1
0
        public async Task ConnectAsync(CommandContext ctx,
                                       [Description("Channel.")] DiscordChannel channel = null)
        {
            VoiceNextExtension vnext = ctx.Client.GetVoiceNext();

            if (vnext == null)
            {
                throw new CommandFailedException("VNext is not enabled or configured.");
            }

            VoiceNextConnection vnc = vnext.GetConnection(ctx.Guild);

            if (vnc != null)
            {
                throw new CommandFailedException("Already connected in this guild.");
            }

            DiscordVoiceState vstat = ctx.Member?.VoiceState;

            if ((vstat == null || vstat.Channel == null) && channel == null)
            {
                throw new CommandFailedException("You are not in a voice channel.");
            }

            if (channel == null)
            {
                channel = vstat.Channel;
            }

            vnc = await vnext.ConnectAsync(channel);

            await this.InformAsync(ctx, StaticDiscordEmoji.Headphones, $"Connected to {Formatter.Bold(channel.Name)}.", important : false);
        }
Beispiel #2
0
        public Task DisconnectAsync(CommandContext ctx)
        {
            VoiceNextExtension vnext = ctx.Client.GetVoiceNext();

            if (vnext == null)
            {
                throw new CommandFailedException("VNext is not enabled or configured.");
            }

            VoiceNextConnection vnc = vnext.GetConnection(ctx.Guild);

            if (vnc == null)
            {
                throw new CommandFailedException("Not connected in this guild.");
            }

            if (MusicPlayers.ContainsKey(ctx.Guild.Id))
            {
                MusicPlayers[ctx.Guild.Id].Stop();
                MusicPlayers.TryRemove(ctx.Guild.Id, out _);
            }

            // TODO check await Task.Delay(500);
            vnc.Disconnect();

            return(this.InformAsync(ctx, StaticDiscordEmoji.Headphones, "Disconnected.", important: false));
        }
Beispiel #3
0
        public Bot()
        {
            Instance = this;
            //DownloadAudioClips();

            DiscordConfiguration discordConfiguration = new DiscordConfiguration()
            {
                AutoReconnect         = true,
                Token                 = Config.Instance.Token,
                TokenType             = TokenType.Bot,
                UseInternalLogHandler = true,
                LogLevel              = LogLevel.Info,
                DateTimeFormat        = "MM/dd/yyyy hh:mm:ss tt"
            };

            discord = new DiscordClient(discordConfiguration);
            discord.DebugLogger.LogMessageReceived += LogMessageReceived;

            interactivity = discord.UseInteractivity(new InteractivityConfiguration());
            voice         = discord.UseVoiceNext();
            commands      = discord.UseCommandsNext(new CommandsNextConfiguration()
            {
                StringPrefixes = new[] { Config.Instance.Prefix },
                CaseSensitive  = false
            });

            commands.RegisterCommands <GeneralCommands>();
            commands.RegisterCommands <AudioModule>();
            commands.RegisterCommands <MinecraftCommands>();
            commands.CommandErrored  += CommandErrored;
            commands.CommandExecuted += CommandExecuted;
            //discord.MessageCreated += MessageCreated;
            discord.Ready += Ready;
        }
Beispiel #4
0
        public async Task Join(CommandContext ctx,
                               DiscordChannel chn = null)
        {
            _vnext = ctx.Client.GetVoiceNext();
            if (_vnext == null)
            {
                await ctx.RespondAsync(":x: VNext is not enabled or configured.");

                return;
            }
            VoiceNextConnection vnc = _vnext.GetConnection(ctx.Guild);

            if (vnc != null)
            {
                await ctx.RespondAsync("Already connected.");

                return;
            }
            DiscordVoiceState vstat = ctx.Member?.VoiceState;

            if (vstat?.Channel == null && chn == null)
            {
                await ctx.RespondAsync("You are not in a voice channel.");

                return;
            }
            if (chn == null)
            {
                chn = vstat.Channel;
            }
            await chn.ConnectAsync();

            await ctx.RespondAsync($"Connected to `{chn.Name}`");
        }
Beispiel #5
0
        public async Task Leave(CommandContext ctx)
        {
            DiscordMessage tmp = await ctx.RespondAsync("DC");

            VoiceNextExtension vnext = ctx.Client.GetVoiceNext();
            await tmp.DeleteAsync();

            tmp = await ctx.RespondAsync("DC: GVNC");

            VoiceNextConnection vnc = vnext.GetConnection(ctx.Guild);
            await tmp.DeleteAsync();

            tmp = await ctx.RespondAsync("DC: CVNC");

            if (vnc == null)
            {
                throw new InvalidOperationException("Not connected in this guild.");
            }
            await tmp.DeleteAsync();

            tmp = await ctx.RespondAsync("DC: DCXC");

            vnc.Disconnect();
            await tmp.DeleteAsync();

            await ctx.RespondAsync("👌");
        }
Beispiel #6
0
            private async Task ConnectAndAddToQueueAsync(CommandContext ctx, SongInfo si)
            {
                VoiceNextExtension vnext = ctx.Client.GetVoiceNext();

                if (vnext == null)
                {
                    throw new CommandFailedException("VNext is not enabled or configured.");
                }

                VoiceNextConnection vnc = vnext.GetConnection(ctx.Guild);

                if (vnc == null)
                {
                    await this.ConnectAsync(ctx);

                    vnc = vnext.GetConnection(ctx.Guild);
                }

                if (MusicPlayers.ContainsKey(ctx.Guild.Id))
                {
                    MusicPlayers[ctx.Guild.Id].Enqueue(si);
                    await ctx.RespondAsync("Added to queue:", embed : si.ToDiscordEmbed(this.ModuleColor));
                }
                else
                {
                    if (!MusicPlayers.TryAdd(ctx.Guild.Id, new MusicPlayer(ctx.Client, ctx.Channel, vnc)))
                    {
                        throw new ConcurrentOperationException("Failed to initialize music player!");
                    }
                    MusicPlayers[ctx.Guild.Id].Enqueue(si);
                    var t = Task.Run(() => MusicPlayers[ctx.Guild.Id].StartAsync());
                }
            }
Beispiel #7
0
        public AudioPlayerModule(ILogger <AudioPlayerModule> logger, IBotCoreModule botCoreModule, AudioPlayer config)
        {
            // These dlls are imported via DllImportAttribute which does not trigger BotRunner's assembly resolve functionality
            string opus = "libopus.dll", sodium = "libsodium.dll";

            CopyNativeLib(opus);
            CopyNativeLib(sodium);

            _logger        = logger;
            _botCoreModule = botCoreModule;
            _botCoreModule.CommandHandler.RegisterCommands <AudioPlayerCommands>();
            _botCoreModule.DiscordClient.VoiceStateUpdated += VoiceStateUpdated;

            _config             = config;
            _voiceNextExtension = _botCoreModule.DiscordClient.UseVoiceNext(new VoiceNextConfiguration {
                EnableIncoming = false
            });

            foreach (Track track in config.Tracks)
            {
                if (track.FileName != null && track.FileNames != null)
                {
                    _logger.LogWarning($"Track \"{track.Name}\" has a file name and a list of file names, if the file name is not also included in the list it will not be used as a trigger!");
                }
            }
        }
Beispiel #8
0
 private async Task Client_MessageCreatedAsync(DSharpPlus.EventArgs.MessageCreateEventArgs e)
 {
     if (e.Message.Content.Contains(":foodReview:"))
     {
         VoiceNextExtension voiceNextClient = Program.Client.GetVoiceNext();
         VoiceNextConnection voiceNextCon = voiceNextClient.GetConnection(e.Guild);
         if (voiceNextCon == null)
         {
             foreach (DiscordVoiceState vs in e.Guild.VoiceStates)
             {
                 if (vs.User.Username.Equals(e.Author.Username))
                 {
                     voiceNextCon = await voiceNextClient.ConnectAsync(vs.Channel);
                 }
             }
         }
         if (voiceNextCon == null)
         {
             // user wasnt in a voice channel
             return;
         }
         else
         {
             // await PlayAudio(voiceNextCon, @"AudioFiles\foodReview.mp3");
             voiceNextCon.Disconnect();
         }
     }
 }
Beispiel #9
0
        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>();
        }
Beispiel #10
0
        /// <summary>
        /// Connect to a Voicechannel
        /// </summary>
        /// <param name="channel"></param>
        /// <param name="voiceNext"></param>
        /// <returns>true when successfuly connected, false if not</returns>
        public async Task <bool> ConnectToChannel(DiscordChannel channel, VoiceNextExtension voiceNext)
        {
            if (channel.Type == DSharpPlus.ChannelType.Voice)
            {
                Vnc = await voiceNext.ConnectAsync(channel);

                return(true);
            }
            return(false);
        }
Beispiel #11
0
        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
        }
Beispiel #12
0
        public static async Task Main(string[] args)
        {
            Globals.BotSettings = JsonConvert.DeserializeObject <Settings>(File.ReadAllText(Path.Combine(Globals.AppPath, "config.json")));

            try
            {
                if (Directory.Exists(Path.Combine(Globals.AppPath, "Queue")))
                {
                    Directory.Delete(Path.Combine(Globals.AppPath, "Queue"), true);
                }
            }
            catch
            {
                // Consume "Directory not empty" error
            }

            discord = new DiscordClient(new DiscordConfiguration
            {
                Token                 = Globals.BotSettings.Token,
                TokenType             = TokenType.Bot,
                UseInternalLogHandler = true,
                LogLevel              = LogLevel.Debug,
                AutoReconnect         = true
            });

            commands = discord.UseCommandsNext(new CommandsNextConfiguration
            {
                StringPrefixes      = new [] { "=" },
                EnableMentionPrefix = true,
                EnableDms           = false
            });

            commands.RegisterCommands(Assembly.GetExecutingAssembly());

            commands.CommandExecuted += Commands_CommandExecuted;
            commands.CommandErrored  += Commands_CommandErrored;

            interactivity = discord.UseInteractivity(new InteractivityConfiguration
            {
            });

            voice = discord.UseVoiceNext(new VoiceNextConfiguration
            {
                VoiceApplication = VoiceApplication.Music
            });

            discord.MessageCreated += Discord_MessageCreated;
            AppDomain.CurrentDomain.ProcessExit += CurrentDomain_ProcessExit;

            await discord.ConnectAsync();

            await Task.Delay(-1);
        }
Beispiel #13
0
        public async Task Play(CommandContext ctx, [RemainingText] string queryString)
        {
            VoiceNextExtension vnext = ctx.Client.GetVoiceNext();

            VoiceNextConnection vnc = vnext.GetConnection(ctx.Guild);

            if (vnc == null)
            {
                DiscordChannel chn = ctx.Member?.VoiceState?.Channel;
                if (chn == null)
                {
                    throw new OutputException("You need to be in a voice channel.");
                }

                await vnext.ConnectAsync(chn);
            }

            if (!string.IsNullOrWhiteSpace(queryString))
            {
                await this.Queue(ctx, queryString);

                if (!GuildMusicStatuses.TryGetValue(ctx.Guild.Id, out MusicStatus musicStatus))
                {
                    GuildMusicStatuses.Add(ctx.Guild.Id, new MusicStatus
                    {
                        Skip = false
                    });

                    if (ctx.Client.GetVoiceNext().GetConnection(ctx.Guild) != null)
                    {
                        PlayMusic(ctx);
                    }
                }
                else
                {
                    if (!musicStatus.Skip && ctx.Client.GetVoiceNext().GetConnection(ctx.Guild) != null)
                    {
                        PlayMusic(ctx);
                    }
                }

                return;
            }

            if (!GuildMusicStatuses.TryGetValue(ctx.Guild.Id, out MusicStatus _))
            {
                GuildMusicStatuses.Add(ctx.Guild.Id, new MusicStatus {
                    Skip = false
                });
            }

            PlayMusic(ctx);
        }
Beispiel #14
0
        public async Task RunAsync()
        {
            var json = string.Empty;

            await 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,
                MinimumLogLevel = LogLevel.Debug
            };

            Client = new DiscordClient(config);

            Client.Ready          += OnClientReady;
            Client.GuildAvailable += OnGuildAvailable;
            Client.ClientErrored  += Client_ClientError;

            Client.UseInteractivity(new InteractivityConfiguration
            {
                Timeout = TimeSpan.FromMinutes(1)
            });

            var commandsConfig = new CommandsNextConfiguration
            {
                StringPrefixes      = new [] { configJson.Prefix },
                EnableDms           = false,
                EnableMentionPrefix = true,
            };

            Commands = Client.UseCommandsNext(commandsConfig);

            Commands.CommandExecuted += Commands_CommandExecuted;
            Commands.CommandErrored  += Commands_CommandErrored;

            Commands.RegisterCommands <LolCommands>();
            Commands.RegisterCommands <TeamCommands>();
            Commands.RegisterCommands <PolcrazCommands>();

            Voices = Client.UseVoiceNext();

            await Client.ConnectAsync();

            await Task.Delay(-1);
        }
Beispiel #15
0
        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);

            configJson = JsonConvert.DeserializeObject <Dictionary <string, string> >(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.MessageDeleted += MessageLogger;

            Client.UseInteractivity(new InteractivityConfiguration {
            });

            var commandsConfig = new CommandsNextConfiguration
            {
                StringPrefixes       = new string[] { configJson["Prefix"] },
                CaseSensitive        = false,
                EnableDms            = false,
                EnableMentionPrefix  = true,
                EnableDefaultHelp    = false,
                IgnoreExtraArguments = true
            };

            Commands = Client.UseCommandsNext(commandsConfig);

            Commands.RegisterCommands <ModerationCommands>();
            Commands.RegisterCommands <OsuCommands>();
            Commands.RegisterCommands <UtilityCommands>();
            Commands.RegisterCommands <ImageCommands>();
            Commands.RegisterCommands <VoiceCommands>();

            Commands.CommandErrored += OnCommandError;

            Voice = Client.UseVoiceNext();

            await Client.ConnectAsync();

            await Task.Delay(-1);
        }
Beispiel #16
0
        /// <summary>
        /// Plays music through the music process
        /// </summary>
        /// <param name="vnext">VoiceNext instance</param>
        /// <param name="guild">Guild reference</param>
        /// <param name="song_path">Path to MP3 music file</param>
        /// <returns></returns>
        public async Task PlayFromMemory(VoiceNextExtension vnext, DiscordGuild guild, DiscordMember requested_by, string song_path)
        {
            var vnc = vnext.GetConnection(guild);

            if (vnc == null)
            {
                throw new InvalidOperationException($"I'm not connected to any voice channel! {DiscordEmoji.FromName(vnext.Client, ":thinking:")}");
            }

            if (!File.Exists(song_path))
            {
                throw new FileNotFoundException($"Music file not found! {DiscordEmoji.FromName(vnext.Client, ":(")}");
            }

            if (!this.MusicChannels.TryGetValue(guild.Id, out GuildMusicChannel channel))
            {
                throw new InvalidOperationException("No music channel associated with this guild!");
            }

            this.EnqueueSong(channel, new MusicData
            {
                Source      = song_path,
                Channel     = channel,
                RequestedBy = requested_by,
                MusicType   = MusicTypes.MEMORY
            });

            // Something it's being already played, limit to just enqueueing
            if (channel.IsPlaying)
            {
                return;
            }

            var txStream = vnc.GetTransmitStream();

            txStream.VolumeModifier = channel.Volume / 100f;

            // Start speaking
            channel.IsPlaying = true;
            channel.MusicProc = new MusicProcess(song_path, ProcessStartMode.OUTPUT);

            var ffout = channel.MusicProc.FFMpeg.StandardOutput.BaseStream;
            await ffout.CopyToAsync(txStream);

            await txStream.FlushAsync().ConfigureAwait(false);

            await vnc.WaitForPlaybackFinishAsync();

            // Stop speaking (also sets IsPlaying to false)
            await this.TryDequeueSong(channel);
        }
Beispiel #17
0
        private void BuildClient()
        {
            __discord = new DiscordClient(new DiscordConfiguration
            {
                Token           = __config.GetValue <string>("discord:token"),
                TokenType       = TokenType.Bot,
                MinimumLogLevel = Microsoft.Extensions.Logging.LogLevel.Error
            });


            __interactivity = __discord.UseInteractivity();
            __voice         = __discord.UseVoiceNext();
            __lavalink      = __discord.UseLavalink();
        }
Beispiel #18
0
        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,
                MinimumLogLevel = Microsoft.Extensions.Logging.LogLevel.Debug,
            };

            Client = new DiscordClient(config);

            Client.Ready += Client_Ready;

            Client.UseInteractivity(new InteractivityConfiguration
            {
                Timeout = TimeSpan.FromMinutes(2)
            });


            var commandsConfig = new CommandsNextConfiguration
            {
                StringPrefixes      = new string[] { configJson.Prefix },
                EnableMentionPrefix = true,
                EnableDms           = false,
                DmHelp = true,
            };

            Commands = Client.UseCommandsNext(commandsConfig);
            Commands.RegisterCommands <FunCommands>();
            Commands.RegisterCommands <TeamCommands>();
            Commands.RegisterCommands <UtilitaryCommands>();
            Commands.RegisterCommands <SpecialCommands>();

            voice = Client.UseVoiceNext();

            await Client.ConnectAsync();

            await Task.Delay(-1);
        }
Beispiel #19
0
 public async Task StopListen(CommandContext ctx)
 {
     if (await IsClientConnected(ctx))
     {
         VoiceNextExtension  voiceNextClient = ctx.Client.GetVoiceNext();
         VoiceNextConnection voiceNextCon    = ctx.Client.GetVoiceNext().GetConnection(ctx.Guild);
         if (voiceNextClient.IsIncomingEnabled)
         {
             this.ssrcMap                = new ConcurrentDictionary <uint, ulong>();
             this.ssrcFilemap            = new ConcurrentDictionary <uint, FileStream>();
             voiceNextCon.VoiceReceived += null;
             voiceNextCon.UserSpeaking  += null;
         }
     }
 }
Beispiel #20
0
        public async Task StartListen(CommandContext ctx)
        {
            await JoinIfNotConnected(ctx);

            VoiceNextExtension  voiceNextClient = ctx.Client.GetVoiceNext();
            VoiceNextConnection voiceNextCon    = voiceNextClient.GetConnection(ctx.Guild);

            if (voiceNextClient.IsIncomingEnabled)
            {
                this.ssrcMap                = new ConcurrentDictionary <uint, ulong>();
                this.ssrcFilemap            = new ConcurrentDictionary <uint, FileStream>();
                voiceNextCon.VoiceReceived += this.OnVoiceReceived;
                voiceNextCon.UserSpeaking  += this.OnUserSpeaking;
            }
        }
Beispiel #21
0
        }                                             //To play music
        public async Task RunAsync()
        {
            //Read config from JSON file
            var json = string.Empty;

            using (var fs = File.OpenRead("config.json"))
                using (var sr = new StreamReader(fs, new UTF8Encoding(false)))
                    json = sr.ReadToEnd();

            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(2)
            });

            var commandsConfig = new CommandsNextConfiguration
            {
                StringPrefixes      = new string[] { configJson.Prefix },
                EnableDms           = false,
                EnableMentionPrefix = true,
                DmHelp = false //Bot will send you private message with help command
            };

            Commands = Client.UseCommandsNext(commandsConfig); //To use commands
            Voice    = Client.UseVoiceNext();                  //To play msucic

            //Register our own commands
            Commands.RegisterCommands <NetworkCommands>();
            Commands.RegisterCommands <MusicCommands>(); //Commands that will take care of playing music

            await Client.ConnectAsync();

            await Task.Delay(-1); //this is to prevent the bot to quit unexpectedly
        }
Beispiel #22
0
            public async Task PlayFileAsync(CommandContext ctx,
                                            [RemainingText, Description("Full path to the file to play.")] string filename)
            {
                VoiceNextExtension vnext = ctx.Client.GetVoiceNext();

                if (vnext == null)
                {
                    throw new CommandFailedException("VNext is not enabled or configured.");
                }

                VoiceNextConnection vnc = vnext.GetConnection(ctx.Guild);

                if (vnc == null)
                {
                    await this.ConnectAsync(ctx);

                    vnc = vnext.GetConnection(ctx.Guild);
                }

                if (!File.Exists(filename))
                {
                    throw new CommandFailedException($"File {Formatter.InlineCode(filename)} does not exist.");
                }

                var si = new SongInfo()
                {
                    Title    = filename,
                    Provider = "Server file system",
                    Query    = ctx.Client.CurrentUser.AvatarUrl,
                    Queuer   = ctx.User.Mention,
                    Uri      = filename
                };

                if (MusicPlayers.ContainsKey(ctx.Guild.Id))
                {
                    MusicPlayers[ctx.Guild.Id].Enqueue(si);
                    await ctx.RespondAsync("Added to queue:", embed : si.ToDiscordEmbed(this.ModuleColor));
                }
                else
                {
                    if (!MusicPlayers.TryAdd(ctx.Guild.Id, new MusicPlayer(ctx.Client, ctx.Channel, vnc)))
                    {
                        throw new ConcurrentOperationException("Failed to initialize music player!");
                    }
                    MusicPlayers[ctx.Guild.Id].Enqueue(si);
                    await MusicPlayers[ctx.Guild.Id].StartAsync();
                }
            }
Beispiel #23
0
        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             += ClientReady;
            Client.VoiceStateUpdated += SeriousCommands.MemberJoin;

            Client.UseInteractivity(new InteractivityConfiguration
            {
                Timeout = TimeSpan.FromMinutes(2)
            });;

            var commandsConfig = new CommandsNextConfiguration
            {
                StringPrefixes      = new string[] { configJson.Prefix },
                EnableDms           = true,
                EnableMentionPrefix = true,
                DmHelp = true
            };

            Commands = Client.UseCommandsNext(commandsConfig);

            Commands.RegisterCommands <FunCommands>();
            Commands.RegisterCommands <SeriousCommands>();

            voice = Client.UseVoiceNext();

            await Client.ConnectAsync();

            await Task.Delay(-1);
        }
Beispiel #24
0
        /// <summary>
        /// Stops any currently playing music but does not disconnect from the voice channel
        /// </summary>
        /// <param name="vnext">VoiceNext instance</param>
        /// <param name="guild">Guild reference</param>
        /// <returns></returns>
        public async Task Stop(VoiceNextExtension vnext, DiscordGuild guild)
        {
            var vnc = vnext.GetConnection(guild);

            if (vnc == null)
            {
                throw new InvalidOperationException($"I'm not connected to any voice channel! {DiscordEmoji.FromName(vnext.Client, ":thinking:")}");
            }

            if (!this.MusicChannels.TryGetValue(guild.Id, out GuildMusicChannel channel))
            {
                throw new InvalidOperationException("No music channel associated with this guild!");
            }

            await this.TryDequeueSong(channel);
        }
Beispiel #25
0
        private async void AudioPlayingThread()
        {
            while (true)
            {
                try
                {
                    PlayQueueElement elementToPlay = playQueue.Take();
                    Program.Client.DebugLogger.Info($"Took [{elementToPlay.Filepath}] off the queue");

                    // Connect if not already
                    VoiceNextExtension  voiceNextClient = Program.Client.GetVoiceNext();
                    VoiceNextConnection voiceNextCon    = voiceNextClient.GetConnection(elementToPlay.GuildToJoin);
                    if (voiceNextCon == null)
                    {
                        Program.Client.DebugLogger.Info($"Not currently connected");
                        Task <VoiceNextConnection> voiceNextConTask = voiceNextClient.ConnectAsync(elementToPlay.ChannelToJoin);
                        voiceNextConTask.Wait(new TimeSpan(0, 0, 3));
                        if (voiceNextConTask.IsCompletedSuccessfully)
                        {
                            voiceNextCon = voiceNextConTask.Result;
                            Program.Client.DebugLogger.Info($"Joined: {voiceNextCon.Channel}");
                        }
                        else
                        {
                            Program.Client.DebugLogger.Error($"Could not join: {elementToPlay.ChannelToJoin.Name}");
                            continue;
                        }
                    }

                    await PlayAudio(voiceNextCon, elementToPlay.Filepath);

                    if (playQueue.Count == 0)
                    {
                        voiceNextCon.Disconnect();
                        Program.Client.DebugLogger.Info($"Leaving: {voiceNextCon.Channel}");
                    }
                }
                catch (Exception ex)
                {
                    Program.Client.DebugLogger.Critical($"Exception was caught in the Audio Thread: {ex}");
                }
            }
        }
Beispiel #26
0
        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 <Config>(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;

            var commandsConfig = new CommandsNextConfiguration
            {
                StringPrefixes      = new string[] { configJson.Prefix },
                EnableMentionPrefix = true,
                EnableDms           = false,
                DmHelp = true,
            };

            Commands = Client.UseCommandsNext(commandsConfig);
            Commands.RegisterCommands <TestCommands>();

            Voice = Client.UseVoiceNext(new VoiceNextConfiguration {
                AudioFormat = AudioFormat.Default, EnableIncoming = true
            });

            await Client.ConnectAsync();

            await Task.Delay(-1);
        }
Beispiel #27
0
        /// <summary>
        /// Joins a voice channel
        /// </summary>
        /// <param name="vnext">VoiceNext instance</param>
        /// <param name="voiceChannel">Voice channel to join</param>
        /// <returns></returns>
        public async Task <GuildMusicChannel> JoinVoiceChannel(VoiceNextExtension vnext, DiscordChannel voiceChannel)
        {
            var vnc = vnext.GetConnection(voiceChannel.Guild);

            var channel = new GuildMusicChannel(voiceChannel.Guild);

            if (!this.MusicChannels.TryAdd(voiceChannel.GuildId, channel))
            {
                // If the add fails, it means there is already a channel for this guild, recover it
                this.MusicChannels.TryGetValue(voiceChannel.GuildId, out channel);
            }
            channel.IsConnected = true;

            if (vnc != null)
            {
                return(channel);
            }

            vnc = await vnext.ConnectAsync(voiceChannel);

            return(channel);
        }
Beispiel #28
0
        /// <summary>
        /// Leaves the voice channel where the bot is currently connected for a given guild
        /// </summary>
        /// <param name="vnext">VoiceNext instance</param>
        /// <param name="guild">Guild reference</param>
        public async Task LeaveVoiceChannel(VoiceNextExtension vnext, DiscordGuild guild)
        {
            var vnc = vnext.GetConnection(guild);

            if (vnc == null)
            {
                throw new InvalidOperationException($"I'm not connected to any voice channel! {DiscordEmoji.FromName(vnext.Client, ":thinking:")}");
            }

            if (!this.MusicChannels.TryGetValue(guild.Id, out GuildMusicChannel channel))
            {
                throw new InvalidOperationException("No music channel associated with this guild!");
            }

            if (await this.TryDequeueSong(channel) && !channel.Queue.IsEmpty)
            {
                channel.Queue.Clear();
            }

            channel.IsConnected = false;
            vnc.Dispose();
        }
Beispiel #29
0
        public async Task Join(CommandContext ctx)
        {
            VoiceNextExtension vnext = ctx.Client.GetVoiceNext();

            VoiceNextConnection vnc = vnext.GetConnection(ctx.Guild);

            if (vnc != null)
            {
                throw new OutputException("Already connected in this guild.");
            }

            DiscordChannel chn = ctx.Member?.VoiceState?.Channel;

            if (chn == null)
            {
                throw new OutputException("You need to be in a voice channel.");
            }

            vnc = await vnext.ConnectAsync(chn);

            await ctx.RespondAsync($"Connected to channel {vnc.Channel.Name} successfully.");
        }
Beispiel #30
0
        public async Task Join(CommandContext ctx)
        {
            DiscordMessage tmp = await ctx.RespondAsync("JN: GVNC");

            VoiceNextExtension vnext = ctx.Client.GetVoiceNext();
            await tmp.DeleteAsync();

            tmp = await ctx.RespondAsync("JN: GGLD");

            VoiceNextConnection vnc = vnext.GetConnection(ctx.Guild);
            await tmp.DeleteAsync();

            tmp = await ctx.RespondAsync("JN: CVNC");

            if (vnc != null)
            {
                throw new InvalidOperationException("Already connected in this guild.");
            }
            await tmp.DeleteAsync();

            tmp = await ctx.RespondAsync("JN: CCHN");

            DiscordChannel chn = ctx.Member?.VoiceState?.Channel;

            if (chn == null)
            {
                throw new InvalidOperationException("You need to be in a voice channel.");
            }
            await tmp.DeleteAsync();

            tmp = await ctx.RespondAsync("JN: CTXC");

            vnc = await vnext.ConnectAsync(chn);

            await tmp.DeleteAsync();

            await ctx.RespondAsync("👌Connected");
        }