348 lines
11 KiB
C#
348 lines
11 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace Discord.Commands
|
|
{
|
|
public partial class CommandService : IService
|
|
{
|
|
private readonly List<Command> _allCommands;
|
|
private readonly Dictionary<string, CommandMap> _categories;
|
|
private readonly CommandMap _map; //Command map stores all commands by their input text, used for fast resolving and parsing
|
|
|
|
public CommandServiceConfig Config { get; }
|
|
public CommandGroupBuilder Root { get; }
|
|
public DiscordClient Client { get; private set; }
|
|
|
|
//AllCommands store a flattened collection of all commands
|
|
public IEnumerable<Command> AllCommands => _allCommands;
|
|
//Groups store all commands by their module, used for more informative help
|
|
internal IEnumerable<CommandMap> Categories => _categories.Values;
|
|
|
|
public event EventHandler<CommandEventArgs> CommandExecuted = delegate { };
|
|
public event EventHandler<CommandErrorEventArgs> CommandErrored = delegate { };
|
|
|
|
private void OnCommand(CommandEventArgs args)
|
|
=> CommandExecuted(this, args);
|
|
private void OnCommandError(CommandErrorType errorType, CommandEventArgs args, Exception ex = null)
|
|
=> CommandErrored(this, new CommandErrorEventArgs(errorType, args, ex));
|
|
|
|
public CommandService()
|
|
: this(new CommandServiceConfigBuilder())
|
|
{
|
|
}
|
|
public CommandService(CommandServiceConfigBuilder builder)
|
|
: this(builder.Build())
|
|
{
|
|
if (builder.ExecuteHandler != null)
|
|
CommandExecuted += builder.ExecuteHandler;
|
|
if (builder.ErrorHandler != null)
|
|
CommandErrored += builder.ErrorHandler;
|
|
}
|
|
public CommandService(CommandServiceConfig config)
|
|
{
|
|
Config = config;
|
|
|
|
_allCommands = new List<Command>();
|
|
_map = new CommandMap();
|
|
_categories = new Dictionary<string, CommandMap>();
|
|
Root = new CommandGroupBuilder(this);
|
|
}
|
|
|
|
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 =>
|
|
{
|
|
ITextChannel 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 (e.Message.User == null || e.Message.User.Id == Client.CurrentUser.Id) return;
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
//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);
|
|
}
|
|
return;
|
|
}
|
|
var errorArgs2 = new CommandEventArgs(e.Message, null, null);
|
|
OnCommandError(CommandErrorType.BadArgCount, errorArgs2);
|
|
}
|
|
};
|
|
}
|
|
|
|
public Task ShowGeneralHelp(User user, ITextChannel channel, ITextChannel replyChannel = null)
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
bool isFirstCategory = true;
|
|
foreach (var category in _categories)
|
|
{
|
|
bool isFirstItem = true;
|
|
foreach (var group in category.Value.SubGroups)
|
|
{
|
|
string error;
|
|
if (group.IsVisible && (group.HasSubGroups || group.HasNonAliases) && group.CanRun(user, channel, out error))
|
|
{
|
|
if (isFirstItem)
|
|
{
|
|
isFirstItem = false;
|
|
//This is called for the first item in each category. If we never get here, we dont bother writing the header for a category type (since it's empty)
|
|
if (isFirstCategory)
|
|
{
|
|
isFirstCategory = false;
|
|
//Called for the first non-empty category
|
|
output.AppendLine("These are the commands you can use:");
|
|
}
|
|
else
|
|
output.AppendLine();
|
|
if (category.Key != "")
|
|
{
|
|
output.Append(Format.Bold(category.Key));
|
|
output.Append(": ");
|
|
}
|
|
}
|
|
else
|
|
output.Append(", ");
|
|
output.Append('`');
|
|
output.Append(group.Name);
|
|
if (group.HasSubGroups)
|
|
output.Append("*");
|
|
output.Append('`');
|
|
}
|
|
}
|
|
}
|
|
|
|
if (output.Length == 0)
|
|
output.Append("There are no commands you have permission to run.");
|
|
else
|
|
output.AppendLine("\n\nRun `help <command>` for more information.");
|
|
|
|
return (replyChannel ?? channel).SendMessage(output.ToString());
|
|
}
|
|
|
|
private Task ShowCommandHelp(CommandMap map, User user, ITextChannel channel, ITextChannel replyChannel = null)
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
|
|
IEnumerable<Command> cmds = map.Commands;
|
|
bool isFirstCmd = true;
|
|
string error;
|
|
if (cmds.Any())
|
|
{
|
|
foreach (var cmd in cmds)
|
|
{
|
|
if (cmd.CanRun(user, channel, out error))
|
|
{
|
|
if (isFirstCmd)
|
|
isFirstCmd = false;
|
|
else
|
|
output.AppendLine();
|
|
ShowCommandHelpInternal(cmd, user, channel, output);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
output.Append('`');
|
|
output.Append(map.FullName);
|
|
output.Append("`\n");
|
|
}
|
|
|
|
bool isFirstSubCmd = true;
|
|
foreach (var subCmd in map.SubGroups.Where(x => x.CanRun(user, channel, out error) && x.IsVisible))
|
|
{
|
|
if (isFirstSubCmd)
|
|
{
|
|
isFirstSubCmd = false;
|
|
output.AppendLine("Sub Commands: ");
|
|
}
|
|
else
|
|
output.Append(", ");
|
|
output.Append('`');
|
|
output.Append(subCmd.Name);
|
|
if (subCmd.SubGroups.Any())
|
|
output.Append("*");
|
|
output.Append('`');
|
|
}
|
|
|
|
if (isFirstCmd && isFirstSubCmd) //Had no commands and no subcommands
|
|
{
|
|
output.Clear();
|
|
output.AppendLine("There are no commands you have permission to run.");
|
|
}
|
|
|
|
return (replyChannel ?? channel).SendMessage(output.ToString());
|
|
}
|
|
public Task ShowCommandHelp(Command command, User user, ITextChannel channel, ITextChannel replyChannel = null)
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
string error;
|
|
if (!command.CanRun(user, channel, out error))
|
|
output.AppendLine(error ?? "You do not have permission to access this command.");
|
|
else
|
|
ShowCommandHelpInternal(command, user, channel, output);
|
|
return (replyChannel ?? channel).SendMessage(output.ToString());
|
|
}
|
|
private void ShowCommandHelpInternal(Command command, User user, ITextChannel channel, StringBuilder output)
|
|
{
|
|
output.Append('`');
|
|
output.Append(command.Text);
|
|
foreach (var param in command.Parameters)
|
|
{
|
|
switch (param.Type)
|
|
{
|
|
case ParameterType.Required:
|
|
output.Append($" <{param.Name}>");
|
|
break;
|
|
case ParameterType.Optional:
|
|
output.Append($" [{param.Name}]");
|
|
break;
|
|
case ParameterType.Multiple:
|
|
output.Append($" [{param.Name}...]");
|
|
break;
|
|
case ParameterType.Unparsed:
|
|
output.Append($" [-]");
|
|
break;
|
|
}
|
|
}
|
|
output.AppendLine("`");
|
|
output.AppendLine($"{command.Description ?? "No description."}");
|
|
|
|
if (command.Aliases.Any())
|
|
output.AppendLine($"Aliases: `" + string.Join("`, `", command.Aliases) + '`');
|
|
}
|
|
|
|
public void CreateGroup(string cmd, Action<CommandGroupBuilder> config = null) => Root.CreateGroup(cmd, config);
|
|
public CommandBuilder CreateCommand(string cmd) => Root.CreateCommand(cmd);
|
|
|
|
internal void AddCommand(Command command)
|
|
{
|
|
_allCommands.Add(command);
|
|
|
|
//Get category
|
|
CommandMap category;
|
|
string categoryName = command.Category ?? "";
|
|
if (!_categories.TryGetValue(categoryName, out category))
|
|
{
|
|
category = new CommandMap();
|
|
_categories.Add(categoryName, category);
|
|
}
|
|
|
|
//Add main command
|
|
category.AddCommand(command.Text, command, false);
|
|
_map.AddCommand(command.Text, command, false);
|
|
|
|
//Add aliases
|
|
foreach (var alias in command.Aliases)
|
|
{
|
|
category.AddCommand(alias, command, true);
|
|
_map.AddCommand(alias, command, true);
|
|
}
|
|
}
|
|
}
|
|
}
|