Esempio n. 1
0
        void IService.Install(DiscordClient client)
        {
            Client = client;

            if (Config.HelpMode != HelpMode.Disabled)
            {
                CreateCommand("help")
                .Parameter("command", ParameterType.Multiple)
                .Hide()
                .Description("Returns information about commands.")
                .Do(async e =>
                {
                    Channel replyChannel = Config.HelpMode == HelpMode.Public ? e.Channel : await e.User.CreatePMChannel().ConfigureAwait(false);
                    if (e.Args.Length > 0)                             //Show command help
                    {
                        var map = _map.GetItem(string.Join(" ", e.Args));
                        if (map != null)
                        {
                            await ShowCommandHelp(map, e.User, e.Channel, replyChannel).ConfigureAwait(false);
                        }
                        else
                        {
                            await replyChannel.SendMessage("Unable to display help: Unknown command.").ConfigureAwait(false);
                        }
                    }
                    else     //Show general help
                    {
                        await ShowGeneralHelp(e.User, e.Channel, replyChannel).ConfigureAwait(false);
                    }
                });
            }

            client.MessageReceived += async(s, e) =>
            {
                if (_allCommands.Count == 0)
                {
                    return;
                }

                if (Config.IsSelfBot)
                {
                    if (e.Message.User == null || e.Message.User.Id != Client.CurrentUser.Id)
                    {
                        return;                                                                       // Will only listen to Self
                    }
                }
                else
                if (e.Message.User == null || e.Message.User.Id == Client.CurrentUser.Id)
                {
                    return;                                                                           // Normal expected behavior for bots
                }
                string msg = e.Message.RawText;
                if (msg.Length == 0)
                {
                    return;
                }

                string cmdMsg = null;

                //Check for command char
                if (Config.PrefixChar.HasValue)
                {
                    if (msg[0] == Config.PrefixChar.Value)
                    {
                        cmdMsg = msg.Substring(1);
                    }
                }

                //Check for mention
                if (cmdMsg == null && Config.AllowMentionPrefix)
                {
                    string mention = client.CurrentUser.Mention;
                    if (msg.StartsWith(mention) && msg.Length > mention.Length)
                    {
                        cmdMsg = msg.Substring(mention.Length + 1);
                    }
                    else
                    {
                        mention = $"@{client.CurrentUser.Name}";
                        if (msg.StartsWith(mention) && msg.Length > mention.Length)
                        {
                            cmdMsg = msg.Substring(mention.Length + 1);
                        }
                    }

                    string mention2 = client.CurrentUser.NicknameMention;
                    if (mention2 != null)
                    {
                        if (msg.StartsWith(mention2) && msg.Length > mention2.Length)
                        {
                            cmdMsg = msg.Substring(mention2.Length + 1);
                        }
                        else
                        {
                            mention2 = $"@{client.CurrentUser.Name}";
                            if (msg.StartsWith(mention2) && msg.Length > mention2.Length)
                            {
                                cmdMsg = msg.Substring(mention2.Length + 1);
                            }
                        }
                    }
                }

                //Check using custom activator
                if (cmdMsg == null && Config.CustomPrefixHandler != null)
                {
                    int index = Config.CustomPrefixHandler(e.Message);
                    if (index >= 0)
                    {
                        cmdMsg = msg.Substring(index);
                    }
                }

                if (cmdMsg == null)
                {
                    return;
                }

                //Parse command
                IEnumerable <Command> commands;
                int argPos;
                CommandParser.ParseCommand(cmdMsg, _map, out commands, out argPos);
                if (commands == null)
                {
                    CommandEventArgs errorArgs = new CommandEventArgs(e.Message, null, null);
                    OnCommandError(CommandErrorType.UnknownCommand, errorArgs);
                    return;
                }
                else
                {
                    foreach (var command in commands)
                    {
                        //Parse arguments
                        string[] args;
                        var      error = CommandParser.ParseArgs(cmdMsg, argPos, command, out args);
                        if (error != null)
                        {
                            if (error == CommandErrorType.BadArgCount)
                            {
                                continue;
                            }
                            else
                            {
                                var errorArgs = new CommandEventArgs(e.Message, command, null);
                                OnCommandError(error.Value, errorArgs);
                                return;
                            }
                        }

                        var eventArgs = new CommandEventArgs(e.Message, command, args);

                        // Check permissions
                        string errorText;
                        if (!command.CanRun(eventArgs.User, eventArgs.Channel, out errorText))
                        {
                            OnCommandError(CommandErrorType.BadPermissions, eventArgs, errorText != null ? new Exception(errorText) : null);
                            return;
                        }

                        // Run the command
                        try
                        {
                            OnCommand(eventArgs);
                            await command.Run(eventArgs).ConfigureAwait(false);
                        }
                        catch (Exception ex)
                        {
                            OnCommandError(CommandErrorType.Exception, eventArgs, ex);
                            DiscordBotLog.AppendLog(DiscordBotLog.BuildCommandExceptionMessage(ex, eventArgs));
                        }
                        return;
                    }
                    var errorArgs2 = new CommandEventArgs(e.Message, null, null);
                    OnCommandError(CommandErrorType.BadArgCount, errorArgs2);
                }
            };
        }
Esempio n. 2
0
        void IService.Install(DiscordClient client)
        {
            Client = client;
            Config.Lock();

            if (Config.HelpMode != HelpMode.Disable)
            {
                CreateCommand("help")
                .Parameter("command", ParameterType.Multiple)
                .Hide()
                .Description("Returns information about commands.")
                .Do(async e =>
                {
                    Channel replyChannel = Config.HelpMode == HelpMode.Public ? e.Channel : await e.User.CreatePMChannel().ConfigureAwait(false);
                    if (e.Args.Length > 0)                             //Show command help
                    {
                        var map = _map.GetItem(string.Join(" ", e.Args));
                        if (map != null)
                        {
                            await ShowCommandHelp(map, e.User, e.Channel, replyChannel).ConfigureAwait(false);
                        }
                        else
                        {
                            await replyChannel.SendMessage("Unable to display help: Unknown command.").ConfigureAwait(false);
                        }
                    }
                    else     //Show general help
                    {
                        await ShowGeneralHelp(e.User, e.Channel, replyChannel);
                    }
                });
            }

            client.MessageReceived += async(s, e) =>
            {
                if (_allCommands.Count == 0)
                {
                    return;
                }
                if (e.Message.User == null || e.Message.User.Id == Client.CurrentUser.Id)
                {
                    return;
                }

                string msg = e.Message.RawText;
                if (msg.Length == 0)
                {
                    return;
                }

                //Check for command char if one is provided
                var chars = Config.CommandChars;
                if (chars.Length > 0)
                {
                    if (!chars.Contains(msg[0]))
                    {
                        return;
                    }
                    msg = msg.Substring(1);
                }

                //Parse command
                IEnumerable <Command> commands;
                int argPos;
                CommandParser.ParseCommand(msg, _map, out commands, out argPos);
                if (commands == null)
                {
                    CommandEventArgs errorArgs = new CommandEventArgs(e.Message, null, null);
                    OnCommandError(CommandErrorType.UnknownCommand, errorArgs);
                    return;
                }
                else
                {
                    foreach (var command in commands)
                    {
                        //Parse arguments
                        string[] args;
                        var      error = CommandParser.ParseArgs(msg, argPos, command, out args);
                        if (error != null)
                        {
                            if (error == CommandErrorType.BadArgCount)
                            {
                                continue;
                            }
                            else
                            {
                                var errorArgs = new CommandEventArgs(e.Message, command, null);
                                OnCommandError(error.Value, errorArgs);
                                return;
                            }
                        }

                        var eventArgs = new CommandEventArgs(e.Message, command, args);

                        // Check permissions
                        string errorText;
                        if (!command.CanRun(eventArgs.User, eventArgs.Channel, out errorText))
                        {
                            OnCommandError(CommandErrorType.BadPermissions, eventArgs, errorText != null ? new Exception(errorText) : null);
                            return;
                        }

                        // Run the command
                        try
                        {
                            OnCommand(eventArgs);
                            await command.Run(eventArgs).ConfigureAwait(false);
                        }
                        catch (Exception ex)
                        {
                            OnCommandError(CommandErrorType.Exception, eventArgs, ex);
                        }
                        return;
                    }
                    var errorArgs2 = new CommandEventArgs(e.Message, null, null);
                    OnCommandError(CommandErrorType.BadArgCount, errorArgs2);
                }
            };
        }