public void Install(ModuleManager manager)
{
_client = manager.Client;
_client.UserJoined += async (s, e) =>
{
var buffer = string.Format("Welcome to '{0}', {1}\n\n", e.Server, Mention.User(e.User));
buffer += _client.Commands().AllCommands.ToDiscordMessage();
await _client.SendPrivateMessage(e.User, buffer);
await _client.SendMessage(e.Server.DefaultChannel, string.Format("A wild {0} appears!", Mention.User(e.User)));
};
_client.UserLeft += async (s, e) =>
{
await _client.SendMessage(e.Server.DefaultChannel, string.Format("See you soon, {0}!", Mention.User(e.User)));
};
_client.ChannelUpdated += async (s, e) =>
{
if (_botServices.Server.ChannelTopicUpdated(e.Channel))
{
await _client.SendMessage(e.Channel, string.Format("**Topic Updated**\n'{0}'", e.Channel.Topic));
}
};
/*_client.UserPresenceUpdated += async (s, e) =>
{
if (_botServices.Server.UserHasReturned(e.Server, e.User))
{
//await _client.SendMessage(e.Server.DefaultChannel, string.Format("Welcome back, {0}!", Mention.User(e.User)));
}
};*/
_client.ChannelCreated += async (sender, e) =>
{
await _client.SendMessage(e.Server.DefaultChannel, string.Format("**New Channel Created**\n{0}", Mention.Channel(e.Channel)));
};
_client.MessageReceived += async (s, e) =>
{
if (e.Message.IsAuthor)
return;
var reply = _botServices.AI.GetReply(e.Message.Channel, e.Message);
if(!string.IsNullOrEmpty(reply))
{
await _client.SendMessage(e.Message.Channel, reply);
}
};
_botServices.Ticker.OnTicked += async (s, e) =>
{
if (_botServices.Ticker.TicksElapsed(e.Ticks, 240))
{
await Announce(e);
}
};
}
public void Install(ModuleManager manager)
{
_client = manager.Client;
manager.CreateCommands("", group =>
{
//group.MinPermissions((int)PermissionLevel.User);
group.CreateCommand("who")
.Description("picks a random online member")
.Do(async e =>
{
var onlineMembers = e.Channel.Members.Where(m => m.Status != UserStatus.Offline);
var random = new Random().Next(0, onlineMembers.Count());
var randomUser = onlineMembers.ElementAt(random);
var message = string.Format("{0}!", Mention.User(randomUser));
await _client.SendMessage(e.Message.Channel, message);
});
group.CreateCommand("help")
.Description("sends a list of commands")
.Do(async e =>
{
await _client.SendMessage(e.Message.Channel, _client.Commands().AllCommands.ToDiscordMessage());
});
group.CreateCommand("uptime")
.Description("shows how long the bot has been online for")
.Do(async e =>
{
var difference = DateTime.Now.Subtract(_botServices.Ticker.ConnectedOn);
var message = string.Format("I've been online for **{0}** days, **{1}** hours & **{2}** minutes.", difference.Days, difference.Hours, difference.Minutes);
await _client.SendMessage(e.Message.Channel, message);
});
// https://discordapp.com/invite/0LOWyaMvOUdtZuYL VK
group.CreateCommand("join")
.Description("requests the bot to join another server.")
.Parameter("invite url")
.Do(async e =>
{
var invite = await _client.GetInvite(e.Args[0]);
if (invite.IsRevoked)
{
return;
}
await _client.AcceptInvite(invite);
});
group.CreateCommand("leave")
.Description("instructs the bot to leave this server.")
.Do(async e =>
{
await _client.SendMessage(e.Channel, $"Leaving~");
//await _client.LeaveServer(e.Server);
});
});
_client.MessageReceived += (s, e) =>
{
if (e.Message.IsAuthor)
return;
if (!e.Message.Text.StartsWith("!"))
{
_botServices.Events.AddEvent(e.Message.Server, e.Message.Channel, e.Message.User, EventType.Message);
}
if (e.Message.MentionedUsers.Any())
{
foreach(var mentionedUser in e.Message.MentionedUsers)
{
if (!Equals(mentionedUser, e.Message.User))
{
_botServices.Events.AddEvent(e.Message.Server, e.Message.Channel, mentionedUser, EventType.Mention);
}
}
}
};
}
private void Start(string[] args)
{
GlobalSettings.Load();
//Set up the base client itself with no voice and small message queues
_client = new DiscordClient(new DiscordConfig
{
AppName = "VoltBot",
AppUrl = "https://github.com/RogueException/DiscordBot",
AppVersion = DiscordConfig.LibVersion,
LogLevel = LogSeverity.Info,
MessageCacheSize = 0,
UsePermissionsCache = false
})
//** Core Services **//
//These are services adding functionality from other Discord.Net.XXX packages
//Enable commands on this bot and activate the built-in help command
.UsingCommands(new CommandServiceConfig
{
CommandChar = '~',
HelpMode = HelpMode.Public
})
//Enable command modules
.UsingModules()
//Enable audio support
.UsingAudio(new AudioServiceConfig
{
Mode = AudioMode.Outgoing,
EnableMultiserver = false,
EnableEncryption = true,
Bitrate = 512,
BufferLength = 10000
})
//** Command Permission Services **//
// These allow you to use permission checks on commands or command groups, or apply a permission globally (such as a blacklist)
//Add a blacklist service so we can add people that can't run any commands. We have used a whitelist instead to restrict it to just us.
.UsingGlobalBlacklist()
//.EnableGlobalWhitelist(GlobalSettings.Users.DevId))
//Assign users to our own role system based on their permissions in the server/channel a command is run in.
.UsingPermissionLevels((u, c) =>
{
if (u.Id == GlobalSettings.Users.DevId)
return (int)PermissionLevel.BotOwner;
if (u.Server != null)
{
if (u == c.Server.Owner)
return (int)PermissionLevel.ServerOwner;
var serverPerms = u.ServerPermissions;
if (serverPerms.ManageRoles)
return (int)PermissionLevel.ServerAdmin;
if (serverPerms.ManageMessages && serverPerms.KickMembers && serverPerms.BanMembers)
return (int)PermissionLevel.ServerModerator;
var channelPerms = u.GetPermissions(c);
if (channelPerms.ManagePermissions)
return (int)PermissionLevel.ChannelAdmin;
if (channelPerms.ManageMessages)
return (int)PermissionLevel.ChannelModerator;
}
return (int)PermissionLevel.User;
})
//** Helper Services**//
//These are used by the modules below, and will likely be removed in the future
.AddService<SettingsService>()
.AddService<HttpService>()
//** Command Modules **//
//Modules allow for events such as commands run or user joins to be filtered to certain servers/channels, as well as provide a grouping mechanism for commands
.AddModule<AdminModule>("Admin", ModuleFilter.ServerWhitelist)
.AddModule<ColorsModule>("Colors", ModuleFilter.ServerWhitelist)
.AddModule<FeedModule>("Feeds", ModuleFilter.ServerWhitelist)
.AddModule<GithubModule>("Repos", ModuleFilter.ServerWhitelist)
.AddModule<ModulesModule>("Modules", ModuleFilter.None)
.AddModule<PublicModule>("Public", ModuleFilter.None)
.AddModule<TwitchModule>("Twitch", ModuleFilter.ServerWhitelist);
//.AddModule(new ExecuteModule(env, exporter), "Execute", ModuleFilter.ServerWhitelist);
//** Events **//
_client.Log.Message += (s, e) => WriteLog(e);
//Display errors that occur when a user tries to run a command
//(In this case, we hide argcount, parsing and unknown command errors to reduce spam in servers with multiple bots)
_client.Commands().CommandErrored += (s, e) =>
{
string msg = e.Exception?.GetBaseException().Message;
if (msg == null) //No exception - show a generic message
{
switch (e.ErrorType)
{
case CommandErrorType.Exception:
//msg = "Unknown error.";
break;
case CommandErrorType.BadPermissions:
msg = "You do not have permission to run this command.";
break;
case CommandErrorType.BadArgCount:
//msg = "You provided the incorrect number of arguments for this command.";
break;
case CommandErrorType.InvalidInput:
//msg = "Unable to parse your command, please check your input.";
break;
case CommandErrorType.UnknownCommand:
//msg = "Unknown command.";
break;
}
}
if (msg != null)
{
_client.ReplyError(e, msg);
_client.Log.Error("Command", msg);
}
};
//Log to the console whenever someone uses a command
_client.Commands().CommandExecuted += (s, e) => _client.Log.Info("Command", $"{e.Command.Text} ({e.User.Name})");
//Used to load private modules outside of this repo
#if PRIVATE
PrivateModules.Install(_client);
#endif
//** Run **//
#if !DNXCORE50
Console.Title = $"{_client.Config.AppName} v{_client.Config.AppVersion} (Discord.Net v{DiscordConfig.LibVersion})";
#endif
//Convert this method to an async function and connect to the server
//DiscordClient will automatically reconnect once we've established a connection, until then we loop on our end
//Note: Run is only needed for Console projects as Main can't be declared as async. UI/Web applications should *not* use this function.
_client.Run(async () =>
{
while (true)
{
try
{
await _client.Connect(GlobalSettings.Discord.Email, GlobalSettings.Discord.Password);
_client.SetGame("Discord.Net");
break;
}
catch (Exception ex)
{
_client.Log.Error($"Login Failed", ex);
await Task.Delay(_client.Config.FailedReconnectDelay);
}
}
});
}
public static Task GenerateCommandMarkdown(DiscordClient client)
=> Task.Run(() =>
{
lock (_commandsMdLock)
{
if (string.IsNullOrEmpty(Config.CommandsMdDir))
{
Logger.FormattedWrite("CommandMd",
"Skipping command.md auto generation. Config.CommandsMdDir was not set.");
return;
}
string tableStart =
$"Commands | Parameters | Description | Default Permissions | Supports DynPerms? {Environment.NewLine}--- | --- | --- | --- | ---";
StringBuilder builder = new StringBuilder()
.AppendLine("# StormBot command table.")
.AppendLine($"This file was automatically generated at {DateTime.UtcNow} UTC.\r\n\r\n")
.AppendLine("### Preface")
.AppendLine(
"This document contains every command, that has been registered in the CommandService system, their paramaters, their desciptions, their default permissions and whether they support dynamic permissions.")
.AppendLine(
"Every command belongs to a cetain module. These modules can be enabled and disabled at will using the Modules module. Each comamnd is seperated into their parent modules command table.")
.AppendLine($"{Environment.NewLine}{Environment.NewLine}")
.AppendLine(
$"Each and every one of these commands can be triggered by saying `{client.Commands().Config.PrefixChar}<command>` or `@<BotName> <command>`")
.AppendLine($"{Environment.NewLine}## Commands");
string currentModule = null;
foreach (Command cmd in client.Commands().AllCommands)
{
if (cmd.Text == "help") continue;
if (cmd.Category == "Personal") continue;
if (currentModule != cmd.Category)
{
currentModule = cmd.Category;
builder.AppendLine($"{Environment.NewLine}#### {currentModule}");
builder.AppendLine(tableStart);
}
builder.Append($"`{cmd.Text}` ");
if (cmd.Aliases.Any())
{
builder.Append("*Aliases*: ");
foreach (string alias in cmd.Aliases)
builder.Append($"`{alias}` ");
builder.Append(" ");
}
builder.Append("|");
foreach (CommandParameter param in cmd.Parameters)
{
switch (param.Type)
{
case ParameterType.Required:
builder.Append($" `<{param.Name}>`");
break;
case ParameterType.Optional:
builder.Append($" `[{param.Name}]`");
break;
case ParameterType.Multiple:
builder.Append($" `[{param.Name}...]`");
break;
case ParameterType.Unparsed:
builder.Append(" `[-]`");
break;
}
}
builder.Append($" | {cmd.Description} | ");
// perms are a bit of a hack seeing as _checks is private.
IPermissionChecker[] checkers = (IPermissionChecker[])
cmd.GetType()
.GetRuntimeFields()
.FirstOrDefault(f => f.Name == "_checks")
.GetValue(cmd);
// get max value of PermissionLevel
PermissionLevel permLevel =
Enum.GetValues(typeof (PermissionLevel)).Cast<PermissionLevel>().Max();
bool supportsDynPerms = false;
foreach (IPermissionChecker permCheck in checkers)
{
PermissionLevelChecker perms = permCheck as PermissionLevelChecker;
if (perms != null)
permLevel = (PermissionLevel) perms.MinPermissions;
DynamicPermissionChecker dynPerms = permCheck as DynamicPermissionChecker;
if (dynPerms != null)
{
supportsDynPerms = true;
permLevel = (PermissionLevel) dynPerms.DefaultPermissionLevel;
}
}
builder.Append($"{permLevel} | ");
builder.Append(supportsDynPerms ? "✓" : "-");
builder.Append(Environment.NewLine);
}
Logger.FormattedWrite("CommandMd", "Generated commands.md", ConsoleColor.Green);
File.WriteAllText(Config.CommandsMdDir, builder.ToString());
}
});
static void Main() {
//load credentials from credentials.json
Credentials c;
try {
c = JsonConvert.DeserializeObject<Credentials>(File.ReadAllText("credentials.json"));
botMention = c.BotMention;
if (c.ForwardMessages != true)
Console.WriteLine("Not forwarding messages.");
else {
ForwardMessages = true;
Console.WriteLine("Forwarding messages.");
}
OwnerID = c.OwnerID;
password = c.Password;
} catch (Exception ex) {
Console.WriteLine("Failed to load stuff from credentials.json, RTFM");
Console.ReadKey();
return;
}
//create new discord client
client = new DiscordClient();
//create a command service
var commandService = new CommandService(new CommandServiceConfig {
CommandChar = null,
HelpMode = HelpMode.Disable
});
//init parse
if (c.ParseKey != null && c.ParseID != null && c.ParseID != "" && c.ParseKey != "") {
ParseClient.Initialize(c.ParseID, c.ParseKey);
//monitor commands for logging
stats_collector = new StatsCollector(commandService);
} else {
Console.WriteLine("Parse key and/or ID not found. Logging disabled.");
}
//reply to personal messages and forward if enabled.
client.MessageReceived += Client_MessageReceived;
//add command service
var commands = client.Services.Add<CommandService>(commandService);
//count commands ran
client.Commands().CommandExecuted += (s, e) => commandsRan++;
//create module service
var modules = client.Services.Add<ModuleService>(new ModuleService());
//add audio service
var audio = client.Services.Add<AudioService>(new AudioService(new AudioServiceConfig() {
Channels = 2,
EnableEncryption = false,
EnableMultiserver = true,
Bitrate = 128,
}));
//install modules
modules.Add(new Administration(), "Administration", ModuleFilter.None);
//run the bot
client.ExecuteAndWait(async () => {
await client.Connect(c.Username, c.Password);
Console.WriteLine("-----------------");
Console.WriteLine(GetStats());
Console.WriteLine("-----------------");
foreach (var serv in client.Servers) {
if ((OwnerUser = serv.GetUser(OwnerID)) != null)
return;
}
});
Console.WriteLine("Exiting...");
Console.ReadKey();
}
