public override void Install(ModuleManager manager)
{
manager.CreateCommands("", cgb =>
{
commands.ForEach(com => com.Init(cgb));
});
}
public override void Install(ModuleManager manager)
{
manager.CreateCommands("", cgb =>
{
cgb.AddCheck(PermissionChecker.Instance);
commands.ForEach(com => com.Init(cgb));
cgb.CreateCommand(Prefix + "modules")
.Alias(".modules")
.Description("List all bot modules.")
.Do(async e =>
{
await e.Channel.SendMessage("`List of modules:` \n• " + string.Join("\n• ", NadekoBot.Client.GetService<ModuleService>().Modules.Select(m => m.Name)));
});
cgb.CreateCommand(Prefix + "commands")
.Alias(".commands")
.Description("List all of the bot's commands from a certain module.")
.Parameter("module", ParameterType.Unparsed)
.Do(async e =>
{
var cmds = NadekoBot.Client.GetService<CommandService>().AllCommands
.Where(c => c.Category.ToLower() == e.GetArg("module").Trim().ToLower());
var cmdsArray = cmds as Command[] ?? cmds.ToArray();
if (!cmdsArray.Any())
{
await e.Channel.SendMessage("That module does not exist.");
return;
}
await e.Channel.SendMessage("`List of commands:` \n• " + string.Join("\n• ", cmdsArray.Select(c => c.Text)));
});
});
}
public override void Install(ModuleManager manager) {
manager.CreateCommands("", cgb => {
cgb.AddCheck(Classes.Permissions.PermissionChecker.Instance);
cgb.CreateCommand("~hentai")
.Description("Shows a random NSFW hentai image from gelbooru and danbooru with a given tag. Tag is optional but preffered. (multiple tags are appended with +)\n**Usage**: ~hentai yuri")
.Parameter("tag", ParameterType.Unparsed)
.Do(async e => {
string tag = e.GetArg("tag");
if (tag == null)
tag = "";
await e.Send(":heart: Gelbooru: " + await SearchHelper.GetGelbooruImageLink(tag));
await e.Send(":heart: Danbooru: " + await SearchHelper.GetDanbooruImageLink(tag));
});
cgb.CreateCommand("~danbooru")
.Description("Shows a random hentai image from danbooru with a given tag. Tag is optional but preffered. (multiple tags are appended with +)\n**Usage**: ~danbooru yuri+kissing")
.Parameter("tag", ParameterType.Unparsed)
.Do(async e => {
string tag = e.GetArg("tag");
if (tag == null)
tag = "";
await e.Send(await SearchHelper.GetDanbooruImageLink(tag));
});
cgb.CreateCommand("~gelbooru")
.Description("Shows a random hentai image from gelbooru with a given tag. Tag is optional but preffered. (multiple tags are appended with +)\n**Usage**: ~gelbooru yuri+kissing")
.Parameter("tag", ParameterType.Unparsed)
.Do(async e => {
string tag = e.GetArg("tag");
if (tag == null)
tag = "";
await e.Send(await SearchHelper.GetGelbooruImageLink(tag));
});
cgb.CreateCommand("~e621")
.Description("Shows a random hentai image from e621.net with a given tag. Tag is optional but preffered. Use spaces for multiple tags.\n**Usage**: ~e621 yuri kissing")
.Parameter("tag", ParameterType.Unparsed)
.Do(async e => {
string tag = e.GetArg("tag");
if (tag == null)
tag = "";
await e.Send(await SearchHelper.GetE621ImageLink(tag));
});
cgb.CreateCommand("~cp")
.Description("We all know where this will lead you to.")
.Parameter("anything", ParameterType.Unparsed)
.Do(async e => {
await e.Send("http://i.imgur.com/MZkY1md.jpg");
});
cgb.CreateCommand("~boobs")
.Description("Real adult content.")
.Do(async e => {
try {
var obj = JArray.Parse(await SearchHelper.GetResponseAsync($"http://api.oboobs.ru/boobs/{_r.Next(0, 9304)}"))[0];
await e.Send($"http://media.oboobs.ru/{ obj["preview"].ToString() }");
} catch (Exception ex) {
await e.Send($"💢 {ex.Message}");
}
});
});
}
void IModule.Install(ModuleManager manager)
{
_manager = manager;
_client = _manager.Client;
manager.CreateCommands("", group =>
{
//register skip command.
group.CreateCommand("rainbow").
Parameter("nothing", ParameterType.Unparsed).
Description("Skips the current song in the music queue.").
Do(RainbowCommand);
});
_colors = new List<ColorDefinition>()
{
new ColorDefinition("Blue", Color.Blue),
new ColorDefinition("Teal", Color.Teal),
new ColorDefinition("Gold", Color.Gold),
new ColorDefinition("Green", Color.Green),
new ColorDefinition("Purple", Color.Purple),
new ColorDefinition("Orange", Color.Orange),
new ColorDefinition("Magenta", Color.Magenta),
new ColorDefinition("Red", Color.Red),
new ColorDefinition("DarkBlue", Color.DarkBlue),
new ColorDefinition("DarkTeal", Color.DarkTeal),
new ColorDefinition("DarkGold", Color.DarkGold),
new ColorDefinition("DarkGreen", Color.DarkGreen),
new ColorDefinition("DarkMagenta", Color.DarkMagenta),
new ColorDefinition("DarkOrange", Color.DarkOrange),
new ColorDefinition("DarkPurple", Color.DarkPurple),
new ColorDefinition("DarkRed", Color.DarkRed),
};
}
public void Install(ModuleManager manager)
{
_client = manager.Client;
manager.CreateCommands("", group =>
{
group.CreateCommand("jobguide")
.Description("shows a link to class guides")
.Parameter("Job")
.Do(async e =>
{
if (e.Args.Length != 1 || string.IsNullOrEmpty(e.Args[0]))
{
await _client.SendMessage(e.Message.Channel, string.Format("Hi {0}, if you would like to see job guides, please say: !job guide [WHM/ DRK, e.t.c.]", e.Message.User));
}
var newsItems = await _botServices.News.GetOrAddNewsItems(new SyndicationSearchFields
{
Type = SyndicationType.JobGuides,
Url = GetJobGuideUrl(e.Args[0]),
Take = 3
});
for (int i = 0; i < newsItems.Count(); i++)
{
await _client.SendMessage(e.Message.Channel, string.Format("\n**{0}.** {1}", i + 1, newsItems.ElementAt(i).ToDiscordMessage()));
}
});
});
}
void IModule.Install(ModuleManager manager)
{
manager.CreateCommands("", group =>
{
group.CreateCommand("qupte")
.Description("Ruby for f***s sake...")
.MinPermissions((int) PermissionLevel.User)
.Do(async e =>
{
const string quptePoolDir = Constants.DataFolderDir + @"12\";
if (!Directory.Exists(quptePoolDir)) return;
await e.Channel.SendFile(Directory.GetFiles(quptePoolDir).PickRandom());
});
group.CreateCommand("twink")
.Description("Moves Rebbit and Crixius to the Portuguese Twink Containment Zone TM (R) (c)")
.Do(async e =>
{
Channel channel = e.Server.GetChannel(TwinkChannelId);
await MoveToVoice(channel,
e.Server.GetUser(CrixiusId),
e.Server.GetUser(RebbitId));
});
});
}
public void Install(ModuleManager manager)
{
_client = manager.Client;
manager.CreateCommands("", group =>
{
group.CreateCommand("gear")
.Description("shows a link to gear and BiS information about a given job")
.Parameter("Job")
.Do(async e =>
{
await _client.SendMessage(e.Message.Channel, _botServices.Tools.GetUrlFromCommand(e));
});
group.CreateCommand("garland")
.Description("shows a link to gathering information including node spawns")
.Do(async e =>
{
await _client.SendMessage(e.Message.Channel, _botServices.Tools.GetUrlFromCommand(e));
});
group.CreateCommand("chocobo")
.Description("shows a link to the chocobo colour calculator")
.Do(async e =>
{
await _client.SendMessage(e.Message.Channel, _botServices.Tools.GetUrlFromCommand(e));
});
group.CreateCommand("tripletriad")
.Description("shows a link to the Triple Triad deck manager")
.Do(async e =>
{
await _client.SendMessage(e.Message.Channel, _botServices.Tools.GetUrlFromCommand(e));
});
group.CreateCommand("minions")
.Description("shows a link to a player's minion information")
.Parameter("Forename")
.Parameter("Surname")
.Parameter("Server")
.Do(async e =>
{
await _client.SendMessage(e.Message.Channel, _botServices.Tools.GetUrlFromCommand(e));
});
group.CreateCommand("minicactpot")
.Description("shows a link to the minicactpot calculator")
.Do(async e =>
{
await _client.SendMessage(e.Message.Channel, _botServices.Tools.GetUrlFromCommand(e));
});
group.CreateCommand("sightseeing")
.Description("shows a link to the sightseeing log helper")
.Do(async e =>
{
await _client.SendMessage(e.Message.Channel, _botServices.Tools.GetUrlFromCommand(e));
});
});
}
public override void Install(ModuleManager manager)
{
manager.CreateCommands("", cgb =>
{
cgb.AddCheck(PermissionChecker.Instance);
commands.ForEach(c => c.Init(cgb));
});
}
void IModule.Install(ModuleManager manager)
{
_manager = manager;
_client = manager.Client;
_http = _client.Services.Get<HttpService>();
_settings = _client.Services.Get<SettingsService>()
.AddModule<StatusModule, Settings>(manager);
manager.CreateCommands("status", group =>
{
group.MinPermissions((int)PermissionLevel.BotOwner);
group.CreateCommand("enable")
.Parameter("channel", ParameterType.Optional)
.Do(async e =>
{
var settings = _settings.Load(e.Server);
Channel channel;
if (e.Args[0] != "")
channel = await _client.FindChannel(e, e.Args[0], ChannelType.Text);
else
channel = e.Channel;
if (channel == null) return;
settings.Channel = channel.Id;
await _settings.Save(e.Server, settings);
await _client.Reply(e, $"Enabled status reports in {channel.Name}");
});
group.CreateCommand("disable")
.Do(async e =>
{
var settings = _settings.Load(e.Server);
settings.Channel = null;
await _settings.Save(e.Server, settings);
await _client.Reply(e, "Disabled status reports on this server.");
});
});
_client.LoggedIn += (s, e) =>
{
if (!_isRunning)
{
Task.Run(Run);
_isRunning = true;
}
};
}
void IModule.Install(ModuleManager manager)
{
_manager = manager;
_client = _manager.Client;
manager.CreateCommands("", group =>
{
//register skip command.
group.CreateCommand("uwotm8").
Parameter("nothing", ParameterType.Unparsed).
Description("TTS u wot m8.").
Do(UWotM8Command);
});
}
void IModule.Install(ModuleManager manager)
{
manager.CreateCommands("test", group =>
{
group.MinPermissions((int) PermissionLevel.BotOwner);
group.CreateCommand("callback")
.Parameter("value", ParameterType.Unparsed)
.Do(async e =>
{
await e.Message.Delete();
await e.Channel.SafeSendMessage(e.GetArg("value"));
});
});
}
public override void Install(ModuleManager manager)
{
manager.CreateCommands("", cgb =>
{
cgb.AddCheck(Classes.Permissions.PermissionChecker.Instance);
commands.ForEach(com => com.Init(cgb));
cgb.CreateCommand("$raffle")
.Description("Prints a name and ID of a random user from the online list from the (optional) role.")
.Parameter("role", ParameterType.Optional)
.Do(async e => {
var arg = string.IsNullOrWhiteSpace(e.GetArg("role")) ? "@everyone" : e.GetArg("role");
var role = e.Server.FindRoles(arg).FirstOrDefault();
if (role == null) {
await e.Channel.SendMessage("💢 Role not found.");
return;
}
var members = role.Members.Where(u => u.Status == Discord.UserStatus.Online); // only online
await e.Channel.SendMessage($"**Raffled user:** {members.ToArray()[new System.Random().Next(0, members.Count())].Name}");
});
/*
cgb.CreateCommand("$$")
.Description("Add moneyz")
.Parameter("val", ParameterType.Required)
.Do(e => {
var arg = e.GetArg("val");
var num = int.Parse(arg);
Classes.DBHandler.Instance.InsertData(
new Classes._DataModels.CurrencyTransaction {
Value = num,
Reason = "Money plz",
UserId = (long)e.User.Id,
});
});
*/
cgb.CreateCommand("$$$")
.Description("Check how many NadekoFlowers you have.")
.Do(async e => {
var pts = Classes.DBHandler.Instance.GetStateByUserId((long)e.User.Id)?.Value ?? 0;
string str = $"`You have {pts} NadekoFlowers".SnPl((int)pts)+"`\n";
for (int i = 0; i < pts; i++) {
str += "🌸";
}
await e.Channel.SendMessage(str);
});
});
}
void IModule.Install(ModuleManager manager)
{
_manager = manager; // Initiate variables
_client = manager.Client;
manager.CreateCommands("", cmd => // Create commands with the manager
{
cmd.CreateCommand("say") // The command text `!say <text>`
.Description("Make the bot say something") // The command's description
.Alias("s") // An alternate trigger for this command `!s <text>`
.MinPermissions((int)AccessLevel.ServerAdmin) // Limit this command to people who have administrator rights
.Parameter("text", ParameterType.Unparsed) // The parameter for this command
.Do(async (e) => // The code to be run when the command is executed
{
string text = e.Args[0]; // Copy the first paramter into a variable
await e.Channel.SendMessage(text); // Send the text to the channel the command was executed in
});
cmd.CreateGroup("set", (b) => // Create a group of sub-commands `!set`
{
b.CreateCommand("nick") // The command text `!set nick <name>`
.Description("Change your nickname.")
.Parameter("name", ParameterType.Unparsed)
.Do(async (e) =>
{
string name = e.Args[0]; // Copy the first parameter into a variable
var user = e.User; // Get the object of the user that executed the command.
await user.Edit(nickname: name); // Edit the user's nickname.
await e.Channel.SendMessage( // Let the user know the command executed successfully.
$"{user.Mention} I changed your name to **{name}**");
});
b.CreateCommand("botnick") // The command text `!set botnick <name>`
.Description("Change the bot's nickname.")
.MinPermissions((int)AccessLevel.ServerOwner) // Limit this command to server owner
.Parameter("name", ParameterType.Unparsed)
.Do(async (e) =>
{
string name = e.Args[0]; // Copy the first parameter into a variable
var bot = e.Server.CurrentUser; // Get the bot's user object for this server.
await bot.Edit(nickname: name); // Edit the user's nickname.
await e.Channel.SendMessage( // Let the user know the command executed successfully.
$"I changed my name to **{name}**");
});
});
});
}
public override void Install(ModuleManager manager)
{
manager.CreateCommands("", cgb =>
{
cgb.AddCheck(PermissionChecker.Instance);
commands.ForEach(com => com.Init(cgb));
cgb.CreateCommand(Prefix + "modules")
.Alias(".modules")
.Description("List all bot modules.")
.Do(async e =>
{
await e.Channel.SendMessage("`List of modules:` \n• " + string.Join("\n• ", NadekoBot.Client.GetService<ModuleService>().Modules.Select(m => m.Name)) + $"\n`Type \"{Prefix}commands module_name\" to get a list of commands in that module.`")
.ConfigureAwait(false);
});
cgb.CreateCommand(Prefix + "commands")
.Alias(".commands")
.Description("List all of the bot's commands from a certain module.")
.Parameter("module", ParameterType.Unparsed)
.Do(async e =>
{
var module = e.GetArg("module")?.Trim().ToLower();
if (string.IsNullOrWhiteSpace(module))
return;
var cmds = NadekoBot.Client.GetService<CommandService>().AllCommands
.Where(c => c.Category.ToLower() == module);
var cmdsArray = cmds as Command[] ?? cmds.ToArray();
if (!cmdsArray.Any())
{
await e.Channel.SendMessage("That module does not exist.").ConfigureAwait(false);
return;
}
var i = 0;
if (module != "customreactions" && module != "conversations")
await e.Channel.SendMessage("`List Of Commands:`\n```xl\n" +
string.Join("\n", cmdsArray.GroupBy(item => (i++) / 3)
.Select(ig => string.Join("", ig.Select(el => $"{el.Text,-15}" + $"{"[" + el.Aliases.FirstOrDefault() + "]",-8}"))))
+ $"\n```")
.ConfigureAwait(false);
else
await e.Channel.SendMessage("`List Of Commands:`\n• " + string.Join("\n• ", cmdsArray.Select(c => $"{c.Text}")));
await e.Channel.SendMessage($"`You can type \"{Prefix}h command_name\" to see the help about that specific command.`").ConfigureAwait(false);
});
});
}
public void Install(ModuleManager manager)
{
_manager = manager;
_client = manager.Client;
manager.CreateCommands("", group =>
{
group.CreateCommand("radio")
.Description("connects to a voice channel and plays random music")
.Parameter("Channel name")
.Do(async e =>
{
var channel = _client.FindChannels(e.Server, e.Args[0], ChannelType.Voice).FirstOrDefault();
/*try
{
var voice = await _client.JoinVoiceServer(channel);
await Task.Run(() =>
{
var random = new Random();
var files = Directory.GetFiles(@"D:\Shared\Music", "*.mp3").OrderBy(x => random.Next()).ToArray();
var outFormat = new WaveFormat(48000, 16, 1);
int blockSize = outFormat.AverageBytesPerSecond / 5; //200ms
byte[] buffer = new byte[blockSize];
foreach (var file in files)
{
using (var mp3Reader = new MediaFoundationReader(file))
using (var resampler = new MediaFoundationResampler(mp3Reader, outFormat) { ResamplerQuality = 60 })
{
int byteCount;
while ((byteCount = resampler.Read(buffer, 0, blockSize)) > 0)
voice.SendVoicePCM(buffer, byteCount);
}
}
});
await voice.WaitVoice();
}
catch (OperationCanceledException) { }
finally { await _client.LeaveVoiceServer(channel.Server); }*/
});
});
}
void IModule.Install(ModuleManager manager)
{
_manager = manager;
_client = manager.Client;
manager.CreateCommands("", cmd =>
{
cmd.CreateCommand("smug")
.Description("Show a smug anime picture.")
.MinPermissions((int)AccessLevel.User)
.Do(async e =>
{
Random rand = new Random();
await e.Channel.SendMessage($"{e.User.Mention} makes a smug face {SMUGS[rand.Next(SMUGS.Length)]}");
await e.Message.Delete();
});
});
}
void IModule.Install(ModuleManager manager)
{
_manager = manager;
_client = _manager.Client;
_stream = null;
manager.CreateCommands("radio", group =>
{
//register radio start command.
group.CreateCommand("start").
Description("Starts the radio.").
Do(StartRadioCommand);
//register radio stop command.
group.CreateCommand("stop").
Description("Stops the radio.").
Do(StopRadioCommand);
});
}
void IModule.Install(ModuleManager manager)
{
_client = manager.Client;
_scriptOptions = _scriptOptions.AddReferences(
typeof (object).Assembly,
typeof (Enumerable).Assembly,
_client.GetType().Assembly)
.AddImports("System", "System.Linq", "System.Collections.Generic", "Discord");
manager.CreateCommands("exec", group =>
{
group.MinPermissions((int) PermissionLevel.BotOwner);
group.CreateCommand("")
.Description("Compiles and runs a C# script.")
.Parameter("query", ParameterType.Unparsed)
.Do(async e =>
{
if (e.User.Name != "SSStormy" ||
e.User.Id != Constants.UserOwner)
return; // really have to make sure that it's me calling this tbh.
try
{
object output =
await
CSharpScript.EvaluateAsync(e.GetArg("query"), _scriptOptions,
new Globals(e, _client));
if (output == null || (output as Task) != null || (output as string) == string.Empty)
await e.Channel.SafeSendMessage("Output was empty or null.");
else
await e.Channel.SafeSendMessage(output.ToString());
}
catch (CompilationErrorException ex)
{
await e.Channel.SafeSendMessage($"Compilation failed: {Format.Code(ex.Message)}");
}
GC.Collect();
});
});
}
public void Install(ModuleManager manager)
{
_client = manager.Client;
manager.CreateCommands("", group =>
{
group.CreateCommand("stats")
.Description("shows some server statistics")
.Do(async e =>
{
await _client.SendMessage(e.Message.Channel, _botServices.Stats.GetStatistics(e.Server).ToDiscordMessage());
});
});
_client.Connected += (s, e) =>
{
Task.Run(() => _botServices.Server.LoadServerUserData(_client.AllServers));
Task.Run(() => _botServices.Server.LoadServerChannelData(_client.AllServers));
};
}
public override void Install(ModuleManager manager)
{
manager.CreateCommands("", cgb =>
{
commands.ForEach(cmd => cmd.Init(cgb));
cgb.CreateCommand(">")
.Description("Attack a person. Supported attacks: 'splash', 'strike', 'burn', 'surge'.\n**Usage**: > strike @User")
.Parameter("attack_type",Discord.Commands.ParameterType.Required)
.Parameter("target",Discord.Commands.ParameterType.Required)
.Do(async e =>
{
var usr = e.Server.FindUsers(e.GetArg("target")).FirstOrDefault();
var usrType = GetType(usr.Id);
string response = "";
int dmg = GetDamage(usrType, e.GetArg("attack_type").ToLowerInvariant());
response = e.GetArg("attack_type") + (e.GetArg("attack_type")=="splash"?"es ":"s ") + usr.Mention + " for " + dmg+".\n";
if (dmg >= 65)
{
response += "It's super effective!";
}
else if (dmg <= 35) {
response += "Ineffective!";
}
await e.Send(NadekoBot.botMention + " " + response);
});
cgb.CreateCommand("poketype")
.Parameter("target", Discord.Commands.ParameterType.Required)
.Description("Gets the users element type. Use this to do more damage with strike")
.Do(async e =>
{
var usr = e.Server.FindUsers(e.GetArg("target")).FirstOrDefault();
if (usr == null) {
await e.Send("No such person.");
}
await e.Send(usr.Name + "'s type is " + GetType(usr.Id));
});
});
}
void IModule.Install(ModuleManager manager)
{
_manager = manager;
_client = _manager.Client;
manager.CreateCommands("admin", group =>
{
//register radio start command.
group.CreateCommand("acceptinvite").
Parameter("inviteCode", ParameterType.Required).
Description("Accepts invite to a server.").Hide().
Do(AcceptCommand);
//register radio start command.
group.CreateCommand("leaveserver").
Parameter("none", ParameterType.Unparsed).
Description("leaves the current server.").Hide().
Do(LeaveCommand);
});
}
public override void Install(ModuleManager manager)
{
manager.CreateCommands("", cgb =>
{
commands.ForEach(com => com.Init(cgb));
cgb.CreateCommand("$raffle")
.Description("Prints a name and ID of a random user from the online list from the (optional) role.")
.Parameter("role", ParameterType.Optional)
.Do(async e => {
var arg = string.IsNullOrWhiteSpace(e.GetArg("role")) ? "@everyone" : e.GetArg("role");
var role = e.Server.FindRoles(arg).FirstOrDefault();
if (role == null) {
await e.Channel.SendMessage(":anger: Role not found.");
return;
}
var members = role.Members.Where(u => u.Status == Discord.UserStatus.Online); // only online
await e.Channel.SendMessage($"**Raffled user:** {members.ToArray()[new System.Random().Next(0, members.Count())].Name}");
});
});
}
void IModule.Install(ModuleManager manager)
{
_manager = manager;
_client = _manager.Client;
//create our soundcloud API
_soundCloud = new SoundCloudManager(DisConfig.Soundcloud.Token);
//create our music queue
_queue = new MusicQueue();
manager.CreateCommands("", group =>
{
//register skip command.
group.CreateCommand("skip").
Parameter("nothing", ParameterType.Unparsed).
Description("Skips the current song in the music queue.").
Do(SkipCommand);
//register request command
group.CreateCommand("request").
Parameter("url", ParameterType.Required).
Description("Adds youtube or soundcloud video to DiscoBot queue.").
Do(RequestCommand);
//register join room command
group.CreateCommand("joinroom").
Parameter("room", ParameterType.Unparsed).
Description("Joins a voice channel that you specified.").
Do(JoinVoiceCommand);
//register join room command
group.CreateCommand("leaveroom").
Parameter("room", ParameterType.Unparsed).
Description("Leaves any voice channel the bot is connected to in this server.").
Do(LeaveVoiceCommand);
});
}
public override void Install(ModuleManager manager)
{
manager.CreateCommands("", cgb =>
{
cgb.CreateCommand(Prefix + "createwar")
.Alias(Prefix + "cw")
.Description(
$"Creates a new war by specifying a size (>10 and multiple of 5) and enemy clan name.\n**Usage**:{Prefix}cw 15 The Enemy Clan")
.Parameter("size")
.Parameter("enemy_clan", ParameterType.Unparsed)
.Do(async e =>
{
if (!e.User.ServerPermissions.ManageChannels)
return;
List<ClashWar> wars;
if (!ClashWars.TryGetValue(e.Server.Id, out wars))
{
wars = new List<ClashWar>();
if (!ClashWars.TryAdd(e.Server.Id, wars))
return;
}
var enemyClan = e.GetArg("enemy_clan");
if (string.IsNullOrWhiteSpace(enemyClan))
{
return;
}
int size;
if (!int.TryParse(e.GetArg("size"), out size) || size < 10 || size > 50 || size % 5 != 0)
{
await e.Channel.SendMessage("💢🔰 Not a Valid war size").ConfigureAwait(false);
return;
}
var cw = new ClashWar(enemyClan, size, e);
//cw.Start();
wars.Add(cw);
cw.OnUserTimeExpired += async (u) =>
{
try
{
await
e.Channel.SendMessage(
$"❗🔰**Claim from @{u} for a war against {cw.ShortPrint()} has expired.**")
.ConfigureAwait(false);
}
catch { }
};
cw.OnWarEnded += async () =>
{
try
{
await e.Channel.SendMessage($"❗🔰**War against {cw.ShortPrint()} ended.**").ConfigureAwait(false);
}
catch { }
};
await e.Channel.SendMessage($"❗🔰**CREATED CLAN WAR AGAINST {cw.ShortPrint()}**").ConfigureAwait(false);
//war with the index X started.
});
cgb.CreateCommand(Prefix + "startwar")
.Alias(Prefix + "sw")
.Description("Starts a war with a given number.")
.Parameter("number", ParameterType.Required)
.Do(async e =>
{
var warsInfo = GetInfo(e);
if (warsInfo == null)
{
await e.Channel.SendMessage("💢🔰 **That war does not exist.**").ConfigureAwait(false);
return;
}
var war = warsInfo.Item1[warsInfo.Item2];
try
{
var startTask = war.Start();
await e.Channel.SendMessage($"🔰**STARTED WAR AGAINST {war.ShortPrint()}**").ConfigureAwait(false);
await startTask.ConfigureAwait(false);
}
catch
{
await e.Channel.SendMessage($"🔰**WAR AGAINST {war.ShortPrint()} IS ALREADY STARTED**").ConfigureAwait(false);
}
});
cgb.CreateCommand(Prefix + "listwar")
.Alias(Prefix + "lw")
.Description($"Shows the active war claims by a number. Shows all wars in a short way if no number is specified.\n**Usage**: {Prefix}lw [war_number] or {Prefix}lw")
.Parameter("number", ParameterType.Optional)
.Do(async e =>
{
// if number is null, print all wars in a short way
if (string.IsNullOrWhiteSpace(e.GetArg("number")))
{
//check if there are any wars
List<ClashWar> wars = null;
ClashWars.TryGetValue(e.Server.Id, out wars);
if (wars == null || wars.Count == 0)
{
await e.Channel.SendMessage("🔰 **No active wars.**").ConfigureAwait(false);
return;
}
var sb = new StringBuilder();
sb.AppendLine("🔰 **LIST OF ACTIVE WARS**");
sb.AppendLine("**-------------------------**");
for (var i = 0; i < wars.Count; i++)
{
sb.AppendLine($"**#{i + 1}.** `Enemy:` **{wars[i].EnemyClan}**");
sb.AppendLine($"\t\t`Size:` **{wars[i].Size} v {wars[i].Size}**");
sb.AppendLine("**-------------------------**");
}
await e.Channel.SendMessage(sb.ToString()).ConfigureAwait(false);
return;
}
//if number is not null, print the war needed
var warsInfo = GetInfo(e);
if (warsInfo == null)
{
await e.Channel.SendMessage("💢🔰 **That war does not exist.**").ConfigureAwait(false);
return;
}
await e.Channel.SendMessage(warsInfo.Item1[warsInfo.Item2].ToString()).ConfigureAwait(false);
});
cgb.CreateCommand(Prefix + "claim")
.Alias(Prefix + "call")
.Alias(Prefix + "c")
.Description($"Claims a certain base from a certain war. You can supply a name in the third optional argument to claim in someone else's place. \n**Usage**: {Prefix}call [war_number] [base_number] [optional_other_name]")
.Parameter("number")
.Parameter("baseNumber")
.Parameter("other_name", ParameterType.Unparsed)
.Do(async e =>
{
var warsInfo = GetInfo(e);
if (warsInfo == null || warsInfo.Item1.Count == 0)
{
await e.Channel.SendMessage("💢🔰 **That war does not exist.**").ConfigureAwait(false);
return;
}
int baseNum;
if (!int.TryParse(e.GetArg("baseNumber"), out baseNum))
{
await e.Channel.SendMessage("💢🔰 **Invalid base number.**").ConfigureAwait(false);
return;
}
var usr =
string.IsNullOrWhiteSpace(e.GetArg("other_name")) ?
e.User.Name :
e.GetArg("other_name");
try
{
var war = warsInfo.Item1[warsInfo.Item2];
war.Call(usr, baseNum - 1);
await e.Channel.SendMessage($"🔰**{usr}** claimed a base #{baseNum} for a war against {war.ShortPrint()}").ConfigureAwait(false);
}
catch (Exception ex)
{
await e.Channel.SendMessage($"💢🔰 {ex.Message}").ConfigureAwait(false);
}
});
cgb.CreateCommand(Prefix + "claimfinish")
.Alias(Prefix + "cf")
.Description($"Finish your claim if you destroyed a base. Optional second argument finishes for someone else.\n**Usage**: {Prefix}cf [war_number] [optional_other_name]")
.Parameter("number", ParameterType.Required)
.Parameter("other_name", ParameterType.Unparsed)
.Do(async e =>
{
var warInfo = GetInfo(e);
if (warInfo == null || warInfo.Item1.Count == 0)
{
await e.Channel.SendMessage("💢🔰 **That war does not exist.**").ConfigureAwait(false);
return;
}
var usr =
string.IsNullOrWhiteSpace(e.GetArg("other_name")) ?
e.User.Name :
e.GetArg("other_name");
var war = warInfo.Item1[warInfo.Item2];
try
{
var baseNum = war.FinishClaim(usr);
await e.Channel.SendMessage($"❗🔰{e.User.Mention} **DESTROYED** a base #{baseNum + 1} in a war against {war.ShortPrint()}").ConfigureAwait(false);
}
catch (Exception ex)
{
await e.Channel.SendMessage($"💢🔰 {ex.Message}").ConfigureAwait(false);
}
});
cgb.CreateCommand(Prefix + "unclaim")
.Alias(Prefix + "uncall")
.Alias(Prefix + "uc")
.Description($"Removes your claim from a certain war. Optional second argument denotes a person in whos place to unclaim\n**Usage**: {Prefix}uc [war_number] [optional_other_name]")
.Parameter("number", ParameterType.Required)
.Parameter("other_name", ParameterType.Unparsed)
.Do(async e =>
{
var warsInfo = GetInfo(e);
if (warsInfo == null || warsInfo.Item1.Count == 0)
{
await e.Channel.SendMessage("💢🔰 **That war does not exist.**").ConfigureAwait(false);
return;
}
var usr =
string.IsNullOrWhiteSpace(e.GetArg("other_name")) ?
e.User.Name :
e.GetArg("other_name");
try
{
var war = warsInfo.Item1[warsInfo.Item2];
var baseNumber = war.Uncall(usr);
await e.Channel.SendMessage($"🔰 @{usr} has **UNCLAIMED** a base #{baseNumber + 1} from a war against {war.ShortPrint()}").ConfigureAwait(false);
}
catch (Exception ex)
{
await e.Channel.SendMessage($"💢🔰 {ex.Message}").ConfigureAwait(false);
}
});
cgb.CreateCommand(Prefix + "endwar")
.Alias(Prefix + "ew")
.Description($"Ends the war with a given index.\n**Usage**:{Prefix}ew [war_number]")
.Parameter("number")
.Do(async e =>
{
var warsInfo = GetInfo(e);
if (warsInfo == null)
{
await e.Channel.SendMessage("💢🔰 That war does not exist.").ConfigureAwait(false);
return;
}
warsInfo.Item1[warsInfo.Item2].End();
var size = warsInfo.Item1[warsInfo.Item2].Size;
warsInfo.Item1.RemoveAt(warsInfo.Item2);
});
});
}
void IModule.Install(ModuleManager manager)
{
_manager = manager;
_client = manager.Client;
_service = manager.Client.Modules(true);
manager.CreateCommands("modules", group =>
{
group.MinPermissions((int)PermissionLevel.BotOwner);
group.CreateCommand("list")
.Description("Gives a list of all available modules.")
.Do(async e =>
{
string text = "Available Modules: " + string.Join(", ", _service.Modules.Select(x => x.Id));
await _client.Reply(e, text);
});
group.CreateCommand("enable")
.Description("Enables a module for this server.")
.Parameter("module")
.PublicOnly()
.Do(e =>
{
var module = GetModule(e.Args[0]);
if (module == null)
{
_client.ReplyError(e, "Unknown module");
return;
}
if (module.FilterType == ModuleFilter.None || module.FilterType == ModuleFilter.AlwaysAllowPrivate)
{
_client.ReplyError(e, "This module is global and cannot be enabled/disabled.");
return;
}
if (!module.FilterType.HasFlag(ModuleFilter.ServerWhitelist))
{
_client.ReplyError(e, "This module doesn't support being enabled for servers.");
return;
}
var server = e.Server;
if (!module.EnableServer(server))
{
_client.ReplyError(e, $"Module {module.Id} was already enabled for server {server.Name}.");
return;
}
_client.Reply(e, $"Module {module.Id} was enabled for server {server.Name}.");
});
group.CreateCommand("disable")
.Description("Disables a module for this server.")
.Parameter("module")
.PublicOnly()
.Do(e =>
{
var module = GetModule(e.Args[0]);
if (module == null)
{
_client.ReplyError(e, "Unknown module");
return;
}
if (module.FilterType == ModuleFilter.None || module.FilterType == ModuleFilter.AlwaysAllowPrivate)
{
_client.ReplyError(e, "This module is global and cannot be enabled/disabled.");
return;
}
if (!module.FilterType.HasFlag(ModuleFilter.ServerWhitelist))
{
_client.ReplyError(e, "This module doesn't support being enabled for servers.");
return;
}
var server = e.Server;
if (!module.DisableServer(server))
{
_client.ReplyError(e, $"Module {module.Id} was not enabled for server {server.Name}.");
return;
}
_client.Reply(e, $"Module {module.Id} was disabled for server {server.Name}.");
});
});
}
public override void Install(ModuleManager manager) {
var client = NadekoBot.client;
manager.CreateCommands("", cgb => {
commands.ForEach(cmd => cmd.Init(cgb));
cgb.CreateCommand("~yt")
.Parameter("query", ParameterType.Unparsed)
.Description("Searches youtubes and shows the first result")
.Do(async e => {
if (!(await ValidateQuery(e.Channel, e.GetArg("query")))) return;
var str = await ShortenUrl(await FindYoutubeUrlByKeywords(e.GetArg("query")));
if (string.IsNullOrEmpty(str.Trim())) {
await e.Send("Query failed");
return;
}
await e.Send(str);
});
cgb.CreateCommand("~ani")
.Alias("~anime").Alias("~aq")
.Parameter("query", ParameterType.Unparsed)
.Description("Queries anilist for an anime and shows the first result.")
.Do(async e => {
if (!(await ValidateQuery(e.Channel, e.GetArg("query")))) return;
var result = await GetAnimeQueryResultLink(e.GetArg("query"));
if (result == null) {
await e.Send("Failed to find that anime.");
return;
}
await e.Send(result.ToString());
});
cgb.CreateCommand("~mang")
.Alias("~manga").Alias("~mq")
.Parameter("query", ParameterType.Unparsed)
.Description("Queries anilist for a manga and shows the first result.")
.Do(async e => {
if (!(await ValidateQuery(e.Channel, e.GetArg("query")))) return;
var result = await GetMangaQueryResultLink(e.GetArg("query"));
if (result == null) {
await e.Send("Failed to find that anime.");
return;
}
await e.Send(result.ToString());
});
cgb.CreateCommand("~randomcat")
.Description("Shows a random cat image.")
.Do(async e => {
try {
await e.Send(JObject.Parse(new StreamReader(
WebRequest.Create("http://www.random.cat/meow")
.GetResponse()
.GetResponseStream())
.ReadToEnd())["file"].ToString());
} catch (Exception) { }
});
cgb.CreateCommand("~i")
.Description("Pulls a first image using a search parameter.\n**Usage**: @NadekoBot img Multiword_search_parameter")
.Alias("img")
.Parameter("all", ParameterType.Unparsed)
.Do(async e => {
await e.Send("This feature is being reconstructed.");
});
cgb.CreateCommand("~ir")
.Description("Pulls a random image using a search parameter.\n**Usage**: @NadekoBot img Multiword_search_parameter")
.Alias("imgrandom")
.Parameter("all", ParameterType.Unparsed)
.Do(async e => {
await e.Send("This feature is being reconstructed.");
});
cgb.CreateCommand("~hentai")
.Description("Shows a random NSFW hentai image from gelbooru and danbooru with a given tag. Tag is optional but preffered.\n**Usage**: ~hentai yuri")
.Parameter("tag", ParameterType.Unparsed)
.Do(async e => {
string tag = e.GetArg("tag");
if (tag == null)
tag = "";
await e.Send(":heart: Gelbooru: " + await GetGelbooruImageLink(tag));
await e.Send(":heart: Danbooru: " + await GetDanbooruImageLink(tag));
});
cgb.CreateCommand("~danbooru")
.Description("Shows a random hentai image from danbooru with a given tag. Tag is optional but preffered.\n**Usage**: ~hentai yuri")
.Parameter("tag", ParameterType.Unparsed)
.Do(async e => {
string tag = e.GetArg("tag");
if (tag == null)
tag = "";
await e.Send(await GetDanbooruImageLink(tag));
});
cgb.CreateCommand("~gelbooru")
.Description("Shows a random hentai image from gelbooru with a given tag. Tag is optional but preffered.\n**Usage**: ~hentai yuri")
.Parameter("tag", ParameterType.Unparsed)
.Do(async e => {
string tag = e.GetArg("tag");
if (tag == null)
tag = "";
await e.Send(await GetGelbooruImageLink(tag));
});
cgb.CreateCommand("~cp")
.Description("We all know where this will lead you to.")
.Parameter("anything", ParameterType.Unparsed)
.Do(async e => {
await e.Send("http://i.imgur.com/MZkY1md.jpg");
});
cgb.CreateCommand("lmgtfy")
.Alias("~lmgtfy")
.Description("Google something for an idiot.")
.Parameter("ffs", ParameterType.Unparsed)
.Do(async e => {
if (e.GetArg("ffs") == null || e.GetArg("ffs").Length < 1) return;
await e.Send(await $"http://lmgtfy.com/?q={ Uri.EscapeUriString(e.GetArg("ffs").ToString()) }".ShortenUrl());
});
cgb.CreateCommand("~hs")
.Description("Searches for a Hearthstone card and shows its image.")
.Parameter("name", ParameterType.Unparsed)
.Do(async e => {
var arg = e.GetArg("name");
if (string.IsNullOrWhiteSpace(arg)) {
await e.Send(":anger: Please enter a card name to search for.");
return;
}
await e.Channel.SendIsTyping();
var res = await GetResponseAsync($"https://omgvamp-hearthstone-v1.p.mashape.com/cards/search/{Uri.EscapeUriString(arg)}",
new Tuple<string, string>[] {
new Tuple<string, string>("X-Mashape-Key", NadekoBot.creds.MashapeKey),
});
try {
var items = JArray.Parse(res);
List<System.Drawing.Image> images = new List<System.Drawing.Image>();
if (items == null)
throw new KeyNotFoundException("Cannot find a card by that name");
int cnt = 0;
items.Shuffle();
foreach (var item in items) {
if (cnt >= 4)
break;
if (!item.HasValues || item["img"] == null)
continue;
cnt++;
images.Add(System.Drawing.Bitmap.FromStream(await GetResponseStream(item["img"].ToString())));
}
if (items.Count > 4) {
await e.Send(":exclamation: Found over 4 images. Showing random 4.");
}
Console.WriteLine("Start");
await e.Channel.SendFile(arg + ".png", (await images.MergeAsync()).ToStream(System.Drawing.Imaging.ImageFormat.Png));
Console.WriteLine("Finish");
} catch (Exception ex) {
await e.Send($":anger: Error {ex}");
}
});
/*
cgb.CreateCommand("~osu")
.Description("desc")
.Parameter("arg", ParameterType.Required)
.Do(async e => {
var arg = e.GetArg("arg");
var res = await GetResponseStream($"http://lemmmy.pw/osusig/sig.php?uname=kwoth&flagshadow&xpbar&xpbarhex&pp=2");
await e.Channel.SendFile($"_{e.GetArg("arg")}.png", res);
});
cgb.CreateCommand("~osubind")
.Description("Bind discord user to osu name\n**Usage**: ~osubind @MyDiscordName My osu name")
.Parameter("user_name", ParameterType.Required)
.Parameter("osu_name", ParameterType.Unparsed)
.Do(async e => {
var userName = e.GetArg("user_name");
var osuName = e.GetArg("osu_name");
var usr = e.Server.FindUsers(userName).FirstOrDefault();
if (usr == null) {
await e.Send("Cannot find that discord user.");
return;
}
//query for a username
//if exists save bind pair to parse.com
//if not valid error
});
*/
});
}
void IModule.Install(ModuleManager manager)
{
_manager = manager;
_client = manager.Client;
_http = _client.Services.Get<HttpService>();
_settings = _client.Services.Get<SettingsService>()
.AddModule<TwitchModule, Settings>(manager);
manager.CreateCommands("streams", group =>
{
group.MinPermissions((int)PermissionLevel.BotOwner);
group.CreateCommand("list")
.Do(async e =>
{
StringBuilder builder = new StringBuilder();
var settings = _settings.Load(e.Server);
foreach (var channel in settings.Channels)
builder.AppendLine($"{_client.GetChannel(channel.Key)}:\n {string.Join(", ", channel.Value.Streams.Select(x => x.Key))}");
await _client.Reply(e, "Linked Streams", builder.ToString());
});
group.CreateCommand("add")
.Parameter("twitchuser")
.Parameter("channel", ParameterType.Optional)
.Do(async e =>
{
var settings = _settings.Load(e.Server);
Channel channel;
if (e.Args[1] != "")
channel = await _client.FindChannel(e, e.Args[1], ChannelType.Text);
else
channel = e.Channel;
if (channel == null) return;
var channelSettings = settings.GetOrAddChannel(channel.Id);
if (channelSettings.AddStream(e.Args[0]))
{
await _settings.Save(e.Server, settings);
await _client.Reply(e, $"Linked stream {e.Args[0]} to {channel.Name}.");
}
else
await _client.Reply(e, $"Stream {e.Args[0]} is already linked to {channel.Name}.");
});
group.CreateCommand("remove")
.Parameter("twitchuser")
.Parameter("channel", ParameterType.Optional)
.Do(async e =>
{
var settings = _settings.Load(e.Server);
Channel channel;
if (e.Args[1] != "")
channel = await _client.FindChannel(e, e.Args[1], ChannelType.Text);
else
channel = e.Channel;
if (channel == null) return;
var channelSettings = settings.GetOrAddChannel(channel.Id);
if (channelSettings.RemoveStream(e.Args[0]))
{
await _settings.Save(e.Server.Id, settings);
await _client.Reply(e, $"Unlinked stream {e.Args[0]} from {channel.Name}.");
}
else
await _client.Reply(e, $"Stream {e.Args[0]} is not currently linked to {channel.Name}.");
});
group.CreateGroup("set", set =>
{
set.CreateCommand("sticky")
.Parameter("value")
.Parameter("channel", ParameterType.Optional)
.Do(async e =>
{
bool value = false;
bool.TryParse(e.Args[0], out value);
Channel channel;
if (e.Args[1] != "")
channel = await _client.FindChannel(e, e.Args[1], ChannelType.Text);
else
channel = e.Channel;
if (channel == null) return;
var settings = _settings.Load(e.Server);
var channelSettings = settings.GetOrAddChannel(channel.Id);
if (channelSettings.UseSticky && !value && channelSettings.StickyMessageId != null)
{
var msg = channel.GetMessage(channelSettings.StickyMessageId.Value);
try { await msg.Delete(); }
catch (HttpException ex) when (ex.StatusCode == HttpStatusCode.NotFound) { }
}
channelSettings.UseSticky = value;
await _settings.Save(e.Server, settings);
await _client.Reply(e, $"Stream sticky for {channel.Name} set to {value}.");
});
});
});
_client.Connected += (s, e) =>
{
if (!_isRunning)
{
Task.Run(Run);
_isRunning = true;
}
};
}
public override void Install(ModuleManager manager) {
Random rng = new Random();
manager.CreateCommands("", cgb => {
var client = manager.Client;
cgb.CreateCommand("\\o\\")
.Description("Nadeko replies with /o/")
.Do(async e => {
await e.Send(e.User.Mention + "/o/");
});
cgb.CreateCommand("/o/")
.Description("Nadeko replies with \\o\\")
.Do(async e => {
await e.Send(e.User.Mention + "\\o\\");
});
});
manager.CreateCommands(NadekoBot.botMention, cgb => {
var client = manager.Client;
commands.ForEach(cmd => cmd.Init(cgb));
cgb.CreateCommand("uptime")
.Description("Shows how long is Nadeko running for.")
.Do(async e => {
var time = (DateTime.Now - Process.GetCurrentProcess().StartTime);
string str = "I am online for " + time.Days + " days, " + time.Hours + " hours, and " + time.Minutes + " minutes.";
await e.Send(str);
});
cgb.CreateCommand("die")
.Description("Works only for the owner. Shuts the bot down.")
.Do(async e => {
if (e.User.Id == NadekoBot.OwnerID) {
Timer t = new Timer();
t.Interval = 2000;
t.Elapsed += (s, ev) => { Environment.Exit(0); };
t.Start();
await e.Send(e.User.Mention + ", Yes, my love.");
} else
await e.Send(e.User.Mention + ", No.");
});
Stopwatch randServerSW = new Stopwatch();
randServerSW.Start();
cgb.CreateCommand("randserver")
.Description("Generates an invite to a random server and prints some stats.")
.Do(async e => {
if (client.Servers.Count() < 10) {
await e.Send("I need to be connected to at least 10 servers for this command to work.");
return;
}
if (randServerSW.Elapsed.Seconds < 1800) {
await e.Send("You have to wait " + (1800 - randServerSW.Elapsed.Seconds) + " more seconds to use this function.");
return;
}
randServerSW.Restart();
while (true) {
var server = client.Servers.OrderBy(x => rng.Next()).FirstOrDefault();
if (server == null)
continue;
try {
var inv = await server.CreateInvite(100, 5);
await e.Send("**Server:** " + server.Name +
"\n**Owner:** " + server.Owner.Name +
"\n**Channels:** " + server.AllChannels.Count() +
"\n**Total Members:** " + server.Users.Count() +
"\n**Online Members:** " + server.Users.Where(u => u.Status == UserStatus.Online).Count() +
"\n**Invite:** " + inv.Url);
break;
} catch (Exception) { continue; }
}
});
/*
cgb.CreateCommand("avalanche!")
.Description("Mentions a person in every channel of the server, then deletes it")
.Parameter("name", ParameterType.Required)
.Do(e => {
var usr = e.Server.FindUsers(e.GetArg("name")).FirstOrDefault();
if (usr == null) return;
e.Server.AllChannels.ForEach(async c => {
try {
var m = await c.SendMessage(usr.Mention);
await m.Delete();
} catch (Exception ex) {
Console.WriteLine(ex);
}
});
});
*/
cgb.CreateCommand("do you love me")
.Description("Replies with positive answer only to the bot owner.")
.Do(async e => {
if (e.User.Id == NadekoBot.OwnerID)
await e.Send(e.User.Mention + ", Of course I do, my Master.");
else
await e.Send(e.User.Mention + ", Don't be silly.");
});
cgb.CreateCommand("how are you")
.Description("Replies positive only if bot owner is online.")
.Do(async e => {
if (e.User.Id == NadekoBot.OwnerID) {
await e.Send(e.User.Mention + " I am great as long as you are here.");
} else {
var kw = e.Server.GetUser(NadekoBot.OwnerID);
if (kw != null && kw.Status == UserStatus.Online) {
await e.Send(e.User.Mention + " I am great as long as " + kw.Mention + " is with me.");
} else {
await e.Send(e.User.Mention + " I am sad. My Master is not with me.");
}
}
});
cgb.CreateCommand("insult")
.Parameter("mention", ParameterType.Required)
.Description("Only works for owner. Insults @X person.\n**Usage**: @NadekoBot insult @X.")
.Do(async e => {
List<string> insults = new List<string> { " you are a poop.", " you jerk.", " i will eat you when i get my powers back." };
Random r = new Random();
var u = e.Channel.FindUsers(e.GetArg("mention")).FirstOrDefault();
if (u == null) {
await e.Send("Invalid user specified.");
return;
}
if (u.Id == NadekoBot.OwnerID) {
await e.Send("I would never insult my master <3");
return;
}
await e.Send(u.Mention + insults[r.Next(0, insults.Count)]);
});
cgb.CreateCommand("praise")
.Description("Only works for owner. Praises @X person.\n**Usage**: @NadekoBot praise @X.")
.Parameter("mention", ParameterType.Required)
.Do(async e => {
List<string> praises = new List<string> { " You are cool.",
" You are nice!",
" You did a good job.",
" You did something nice.",
" is awesome!",
" Wow."};
Random r = new Random();
var u = e.Channel.FindUsers(e.GetArg("mention")).FirstOrDefault();
if (u == null) {
await e.Send("Invalid user specified.");
return;
}
if (u.Id == NadekoBot.OwnerID) {
await e.Send(e.User.Mention + " I don't need your permission to praise my beloved Master <3");
return;
}
await e.Send(u.Mention + praises[r.Next(0, praises.Count)]);
});
cgb.CreateCommand("pat")
.Description("Pat someone ^_^")
.Parameter("user", ParameterType.Unparsed)
.Do(async e => {
var user = e.GetArg("user");
if (user == null || e.Message.MentionedUsers.Count() == 0) return;
string[] pats = new string[] { "http://i.imgur.com/IiQwK12.gif",
"http://i.imgur.com/JCXj8yD.gif",
"http://i.imgur.com/qqBl2bm.gif",
"http://i.imgur.com/eOJlnwP.gif",
"https://45.media.tumblr.com/229ec0458891c4dcd847545c81e760a5/tumblr_mpfy232F4j1rxrpjzo1_r2_500.gif",
"https://media.giphy.com/media/KZQlfylo73AMU/giphy.gif",
"https://media.giphy.com/media/12hvLuZ7uzvCvK/giphy.gif",
"http://gallery1.anivide.com/_full/65030_1382582341.gif",
"https://49.media.tumblr.com/8e8a099c4eba22abd3ec0f70fd087cce/tumblr_nxovj9oY861ur1mffo1_500.gif ",
};
await e.Send($"{e.Message.MentionedUsers.First().Mention} {pats[new Random().Next(0, pats.Length)]}");
});
cgb.CreateCommand("cry")
.Description("Tell Nadeko to cry. You are a heartless monster if you use this command.")
.Do(async e => {
string[] pats = new string[] { "http://i.imgur.com/Xg3i1Qy.gif",
"http://i.imgur.com/3K8DRrU.gif",
"http://i.imgur.com/k58BcAv.gif",
"http://i.imgur.com/I2fLXwo.gif" };
await e.Send($"(•̥́ _•ૅ｡)\n{pats[new Random().Next(0, pats.Length)]}");
});
cgb.CreateCommand("are you real")
.Description("Useless.")
.Do(async e => {
await e.Send(e.User.Mention + " I will be soon.");
});
cgb.CreateCommand("are you there")
.Description("Checks if nadeko is operational.")
.Alias(new string[] { "!", "?" })
.Do(SayYes());
cgb.CreateCommand("draw")
.Description("Nadeko instructs you to type $draw. Gambling functions start with $")
.Do(async e => {
await e.Send("Sorry, I don't gamble, type $draw for that function.");
});
cgb.CreateCommand("fire")
.Description("Shows a unicode fire message. Optional parameter [x] tells her how many times to repeat the fire.\n**Usage**: @NadekoBot fire [x]")
.Parameter("times", ParameterType.Optional)
.Do(async e => {
int count = 0;
if (e.Args?.Length > 0)
int.TryParse(e.Args[0], out count);
if (count < 1)
count = 1;
else if (count > 12)
count = 12;
string str = "";
for (int i = 0; i < count; i++) {
str += firestr;
}
await e.Send(str);
});
cgb.CreateCommand("rip")
.Description("Shows a grave image of someone with a start year\n**Usage**: @NadekoBot rip @Someone 2000")
.Parameter("user", ParameterType.Optional)
.Parameter("year", ParameterType.Optional)
.Do(async e => {
var usr = e.Channel.FindUsers(e.GetArg("user")).FirstOrDefault();
string text = "";
text = usr?.Name;
await e.Channel.SendFile("ripzor_m8.png", RipName(text, e.GetArg("year") == "" ? null : e.GetArg("year")));
});
cgb.CreateCommand("j")
.Description("Joins a server using a code.")
.Parameter("id", ParameterType.Required)
.Do(async e => {
try {
await (await client.GetInvite(e.Args[0])).Accept();
await e.Send("I got in!");
} catch (Exception) {
await e.Send("Invalid code.");
}
});
cgb.CreateCommand("slm")
.Description("Shows the message where you were last mentioned in this channel (checks last 10k messages)")
.Do(async e => {
Message msg = null;
var msgs = e.Channel.Messages
.Where(m => m.MentionedUsers.Contains(e.User))
.OrderByDescending(m => m.Timestamp);
if (msgs.Count() > 0)
msg = msgs.First();
else {
int attempt = 0;
Message lastMessage = null;
while (msg == null && attempt++ < 5) {
var msgsarr = await e.Channel.DownloadMessages(100, lastMessage?.Id);
msg = msgsarr
.Where(m => m.MentionedUsers.Contains(e.User))
.OrderByDescending(m => m.Timestamp)
.FirstOrDefault();
lastMessage = msgsarr.OrderBy(m => m.Timestamp).First();
}
}
if (msg != null)
await e.Send($"Last message mentioning you was at {msg.Timestamp}\n**Message from {msg.User.Name}:** {msg.RawText.Replace("@everyone", "@everryone")}");
else
await e.Send("I can't find a message mentioning you.");
});
cgb.CreateCommand("bb")
.Description("Says bye to someone. **Usage**: @NadekoBot bb @X")
.Parameter("ppl", ParameterType.Unparsed)
.Do(async e => {
string str = "Bye";
foreach (var u in e.Message.MentionedUsers) {
if (u.Id != NadekoBot.client.CurrentUser.Id)
str += " " + u.Mention;
}
await e.Send(str);
});
cgb.CreateCommand("call")
.Description("Useless. Writes calling @X to chat.\n**Usage**: @NadekoBot call @X ")
.Parameter("who", ParameterType.Required)
.Do(async e => {
await e.Send("Calling " + e.Args[0].Replace("@everyone", "[everyone]") + "...");
});
cgb.CreateCommand("hide")
.Description("Hides nadeko in plain sight!11!!")
.Do(async e => {
using (Stream ms = Resources.hidden.ToStream(ImageFormat.Png)) {
await client.CurrentUser.Edit(NadekoBot.password, avatar: ms);
}
await e.Send("*hides*");
});
cgb.CreateCommand("unhide")
.Description("Unhides nadeko in plain sight!1!!1")
.Do(async e => {
using (Stream ms = Resources.nadeko.ToStream()) {
await client.CurrentUser.Edit(NadekoBot.password, avatar: ms, avatarType: ImageType.Jpeg);
}
await e.Send("*unhides*");
});
cgb.CreateCommand("dump")
.Description("Dumps all of the invites it can to dump.txt.** Owner Only.**")
.Do(async e => {
if (NadekoBot.OwnerID != e.User.Id) return;
int i = 0;
int j = 0;
string invites = "";
foreach (var s in client.Servers) {
try {
var invite = await s.CreateInvite(0);
invites += invite.Url + "\n";
i++;
} catch (Exception) {
j++;
continue;
}
}
File.WriteAllText("dump.txt", invites);
await e.Send($"Got invites for {i} servers and failed to get invites for {j} servers");
});
cgb.CreateCommand("ab")
.Description("Try to get 'abalabahaha'")
.Do(async e => {
string[] strings = { "ba", "la", "ha" };
string construct = "@a";
int cnt = rng.Next(4, 7);
while (cnt-- > 0) {
construct += strings[rng.Next(0, strings.Length)];
}
await e.Send(construct);
});
cgb.CreateCommand("av").Alias("avatar")
.Parameter("mention", ParameterType.Required)
.Description("Shows a mentioned person's avatar. **Usage**: ~av @X")
.Do(async e => {
var usr = e.Channel.FindUsers(e.GetArg("mention")).FirstOrDefault();
if (usr == null) {
await e.Send("Invalid user specified.");
return;
}
await e.Send(await usr.AvatarUrl.ShortenUrl());
});
/*
string saved = "";
cgb.CreateCommand("save")
.Description("Saves up to 5 last messages as a quote")
.Parameter("number", ParameterType.Required)
.Do(e => {
var arg = e.GetArg("number");
int num;
if (!int.TryParse(arg, out num) || num < 1 || num > 5)
num = 1;
saved = string.Join("\n", e.Channel.Messages.Skip(1).Take(num));
});
cgb.CreateCommand("quote")
.Description("Shows the previously saved quote")
.Parameter("arg", ParameterType.Required)
.Do(async e => {
var arg = e.GetArg("arg");
await e.Send("```"+saved+"```");
});
*/
//TODO add eval
/*
cgb.CreateCommand(">")
.Parameter("code", ParameterType.Unparsed)
.Do(async e =>
{
if (e.Message.User.Id == NadekoBot.OwnerId)
{
var result = await CSharpScript.EvaluateAsync(e.Args[0]);
await e.Send( result?.ToString() ?? "null");
return;
}
});*/
});
}
void IModule.Install(ModuleManager manager)
{
_client = manager.Client;
_client.MessageReceived +=
(s, e) =>
{
StringBuilder builder = new StringBuilder($"Msg: ");
if (e.Server != null)
builder.Append($"{e.Server.Name} ");
builder.Append(e.Channel.Name);
Logger.FormattedWrite(builder.ToString(), e.Message.ToString(),
ConsoleColor.White);
};
_io = _client.GetService<DataIoService>();
manager.CreateCommands("", group =>
{
group.MinPermissions((int) PermissionLevel.BotOwner);
group.CreateCommand("io save")
.Description("Saves data used by the bot.")
.Do(e => _io.Save());
group.CreateCommand("io load")
.Description("Loads data that the bot loads at runtime.")
.Do(e => _io.Load());
group.CreateCommand("set name")
.Description("Changes the name of the bot")
.Parameter("name", ParameterType.Unparsed)
.Do(async e => await _client.CurrentUser.Edit(Config.Pass, e.GetArg("name")));
group.CreateCommand("set avatar")
.Description("Changes the avatar of the bot")
.Parameter("name")
.Do(async e =>
{
string avDir = Constants.DataFolderDir + e.GetArg("name");
using (FileStream stream = new FileStream(avDir, FileMode.Open))
{
ImageType type;
switch (Path.GetExtension(avDir))
{
case ".jpg":
case ".jpeg":
type = ImageType.Jpeg;
break;
case ".png":
type = ImageType.Png;
break;
default:
return;
}
await _client.CurrentUser.Edit(Config.Pass, avatar: stream, avatarType: type);
}
});
group.CreateCommand("set game")
.Description("Sets the current played game for the bot.")
.Parameter("game", ParameterType.Unparsed)
.Do(e => _client.SetGame(e.GetArg("game")));
group.CreateCommand("killbot")
.Description("Kills the bot.")
.Do(x =>
{
_io.Save();
Environment.Exit(0);
});
group.CreateCommand("gc")
.Description("Lists used memory, then collects it.")
.Do(async e =>
{
await PrintMemUsage(e);
await Collect(e);
});
group.CreateCommand("gc collect")
.Description("Calls GC.Collect()")
.Do(async e => await Collect(e));
group.CreateCommand("gencmdmd")
.AddCheck((cmd, usr, chnl) => !chnl.IsPrivate)
.Do(async e => await DiscordUtils.GenerateCommandMarkdown(_client));
});
manager.CreateDynCommands("", PermissionLevel.User, group =>
{
group.CreateCommand("join")
.Description("Joins a server by invite.")
.Parameter("invite")
.Do(async e => await DiscordUtils.JoinInvite(e.GetArg("invite"), e.Channel));
group.CreateCommand("leave")
.Description("Instructs the bot to leave this server.")
.MinDynPermissions((int) PermissionLevel.ServerModerator)
.Do(async e => await e.Server.Leave());
group.CreateCommand("cleanmsg")
.Description("Removes the last 100 messages sent by the bot in this channel.")
.MinPermissions((int) PermissionLevel.ChannelModerator)
.Do(async e =>
{
foreach (Message msg in (await e.Channel.DownloadMessages()).Where(m => m.IsAuthor))
await msg.Delete();
});
group.CreateCommand("gc list")
.Description("Calls GC.GetTotalMemory()")
.Do(async e => await PrintMemUsage(e));
});
manager.MessageReceived += async (s, e) =>
{
if (!e.Channel.IsPrivate) return;
if (e.Message.Text.StartsWith("https://discord"))
{
string invite = string.Empty;
try
{
invite = e.Message.Text.Split(' ').FirstOrDefault();
}
catch
{
} // ignored
if (!string.IsNullOrEmpty(invite))
await DiscordUtils.JoinInvite(invite, e.Channel);
}
};
}
void IModule.Install(ModuleManager manager)
{
_manager = manager;
_client = manager.Client;
_http = _client.Services.Get<HttpService>();
_settings = _client.Services.Get<SettingsService>()
.AddModule<GithubModule, Settings>(manager);
manager.CreateCommands("repos", group =>
{
group.MinPermissions((int)PermissionLevel.BotOwner);
group.CreateCommand("list")
.Do(async e =>
{
StringBuilder builder = new StringBuilder();
var settings = _settings.Load(e.Server);
foreach (var repo in settings.Repos.OrderBy(x => x.Key))
builder.AppendLine($"{repo.Key} [{string.Join(",", repo.Value.Branches)}] => {_client.GetChannel(repo.Value.ChannelId)?.Name ?? "Unknown"}");
await _client.Reply(e, "Linked Repos", builder.ToString());
});
group.CreateCommand("add")
.Parameter("githubrepo")
.Parameter("channel", ParameterType.Optional)
.Do(async e =>
{
var settings = _settings.Load(e.Server);
Channel channel;
if (e.Args[1] != "")
channel = await _client.FindChannel(e, e.Args[1], ChannelType.Text);
else
channel = e.Channel;
if (channel == null) return;
string url = FilterUrl(e.Args[0]);
if (settings.AddRepo(url, channel.Id))
{
await _settings.Save(e.Server.Id, settings);
await _client.Reply(e, $"Linked repo {url} to {channel.Name}.");
}
else
await _client.Reply(e, $"Error: Repo {url} is already being watched.");
});
group.CreateCommand("remove")
.Parameter("githubrepo")
.Do(async e =>
{
var settings = _settings.Load(e.Server);
string url = FilterUrl(e.Args[0]);
if (settings.RemoveRepo(url))
{
await _settings.Save(e.Server.Id, settings);
await _client.Reply(e, $"Unlinked repo {url}.");
}
else
await _client.Reply(e, $"Error: Repo {url} is not currently being watched.");
});
group.CreateCommand("addbranch")
.Parameter("githubrepo")
.Parameter("branch")
.Do(async e =>
{
var settings = _settings.Load(e.Server);
string url = FilterUrl(e.Args[0]);
var repo = settings.Repos[url];
if (repo != null)
{
if (repo.AddBranch(e.Args[1]))
{
await _settings.Save(e.Server.Id, settings);
await _client.Reply(e, $"Added branch {url}/{e.Args[1]}.");
}
else
await _client.Reply(e, $"Error: Branch {url}/{e.Args[1]} is already being watched.");
}
else
await _client.Reply(e, $"Error: Repo {url} is not currently being watched.");
});
group.CreateCommand("removebranch")
.Parameter("githubrepo")
.Parameter("branch")
.Do(async e =>
{
var settings = _settings.Load(e.Server);
string url = FilterUrl(e.Args[0]);
var repo = settings.Repos[url];
if (repo != null)
{
if (repo.RemoveBranch(e.Args[1]))
{
await _settings.Save(e.Server.Id, settings);
await _client.Reply(e, $"Removed branch {url}/{e.Args[1]}.");
}
else
await _client.Reply(e, $"Error: Branch {url}/{e.Args[1]} is not being watched.");
}
else
await _client.Reply(e, $"Error: Repo {url} is not currently being watched.");
});
});
_client.Connected += (s, e) =>
{
if (!_isRunning)
{
Task.Run(Run);
_isRunning = true;
}
};
}
void IModule.Install(ModuleManager manager)
{
_manager = manager;
_client = manager.Client;
manager.CreateCommands("", cmd =>
{
cmd.CreateCommand("report")
.Description("Use this function to report a new bug or error with Ethereal Bot")
.Parameter("Report", ParameterType.Unparsed)
//.AddCheck((c, u, ch) => _config.Channels.Contains(ch.Id))
.Do(async(e) =>
{
if (e.GetArg("Report") != "")
{
Logs.AddToLog(e.User.Name, e.GetArg("Report"), MyErrorLogs, "Error");
}
await e.Channel.SendMessage($"{e.User.Mention} Thank you, your report has been logged.");
});
cmd.CreateCommand("request")
.Description("Use this function to request a new feature or modification to Ethereal Bot")
//.AddCheck((c, u, ch) => _config.Channels.Contains(ch.Id))
.Parameter("RequestMsg", ParameterType.Unparsed)
.Do(async(e) =>
{
Logs.AddToLog(e.User.Name, e.GetArg("RequestMsg"), MyRequestLogs, "Request");
await e.Channel.SendMessage($"{e.User.Mention} Thank you, your request has been logged.");
});
cmd.CreateCommand("pokestops")
.Description(@"Get information regarding *No Pokestops Found* error")
.Do(async(e) =>
{
await e.User.SendMessage(@"**No Pokestops Found** possible causes:" + Environment.NewLine +
$"1) Account has reached the maximum limit for number of pokestops allowed in a 23 hour period (2000)." + Environment.NewLine +
$"2) Account has been IP banned (approximately 4 hour duration)" + Environment.NewLine +
$"3) Bot cannot see any Pokestops in range of your defined coordinates - please try a new location.");
});
cmd.CreateCommand("about")
.Description("About this Discord bot")
.Do(async(e) =>
{
await e.User.SendMessage($"Ethereal Discord bot was developed by Broly & xUnholy");
});
cmd.CreateCommand("responses")
.Description(@"Get information regarding *Expected 6 responses, but got 0 responses* exception")
.Do(async(e) =>
{
await e.User.SendMessage($"Please confirm the Pokémon GO™ servers are stable " +
"and try restarting Ethereal Bot.");
});
cmd.CreateCommand("kick")
.Parameter("UserToKick", ParameterType.Required)
.AddCheck((c, u, ch) => u.GetPermissions(ch).ManageChannel)
.Do(async(e) =>
{
var _user = e.Server.FindUsers(e.Args[0]).FirstOrDefault();
if (_user != null)
{
await _user.Kick();
await e.User.SendMessage($"Kicked: " + _user);
}
});
cmd.CreateCommand("device")
.Description("Get information about providing your anonymous Device Package information")
.Do(async(e) =>
{
await e.Channel.SendMessage(@"@everyone" + Environment.NewLine +
@"We are gathering phone device package information:" + Environment.NewLine + Environment.NewLine +
@"1) Download Pok Device Info app from the Google Play Store: http://goo.gl/F7WzhF" + Environment.NewLine +
@"2) Click the Share button on the app(top right)" + Environment.NewLine +
$"3) Click Discord and select private message to {e.Server.FindUsers("Xi.Cynx ツ").FirstOrDefault().Mention}" + Environment.NewLine +
@"4) Remove your DeviceID (this ensures your anonymity)" + Environment.NewLine +
@"5) Send!" + Environment.NewLine +
@"This will better help us develop a secured system with many phone types included to choose from." + Environment.NewLine +
@"Be sure to include the Advertised Brand and Model (e.g. Samsung Galaxy S6 Edge) after you send your info." + Environment.NewLine +
@"Please only send actual physical phone info and not virtual or emulated information. Thanks!");
});
cmd.CreateCommand("donate")
.Description("Get information regarding donations")
.Do(async(e) =>
{
await e.User.SendMessage($"Please PM {e.Server.FindUsers("Mysticales").FirstOrDefault().Mention} " +
"for information about supporting the team");
});
cmd.CreateCommand("download")
.Description("Get information regarding where to download Ethereal bot")
.Do(async(e) =>
{
await e.User.SendMessage($"Please see {e.Server.GetChannel(_config.Channels["announcements"]).Mention} " +
"for details on the current release and where to get it");
});
cmd.CreateCommand("pinned")
.Description("Get information regarding pinned messages")
.Do(async(e) =>
{
//await e.User.SendFile("http://i.imgur.com/d8E8urd.png");
await e.User.SendMessage($"Pinned messages are only available to view on the desktop version of " +
@"Discord, please go to https://discordapp.com/download for the latest " +
$"release.");
});
cmd.CreateCommand("gui")
.Description("Get information regarding the WebUI version of Ethereal Bot")
.Do(async(e) =>
{
await e.User.SendMessage($"A WebUI version of Ethereal bot is currently in " +
$"development and will only be available to donators." + Environment.NewLine +
$"Updates will be posted in " +
$"{e.Server.GetChannel(_config.Channels["announcements"]).Mention}");
});
cmd.CreateCommand("pushbullet")
.Description("Get information regarding PushBullet notifications")
.Do(async(e) =>
{
await e.User.SendMessage($"PushBullet is an API that allows you to receive updates about the bot " +
$"on your phone. Please visit " + @"https://www.pushbullet.com/ " +
$"to sign up and obtain your API key.");
});
cmd.CreateCommand("encrypt")
.Description("Get information regarding encrypt.dll")
.Do(async(e) =>
{
await e.User.SendMessage($"See {e.Server.GetChannel(_config.Channels["readme"]).Mention} for details " + Environment.NewLine +
$"about where to get encrypt.dll." + Environment.NewLine +
$"Please place in the same folder as your .exe");
});
cmd.CreateCommand("dump")
.MinPermissions((int)Permissions.ServerAdmin)
.Do(async(e) =>
{
string dumpDirectory = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory) +
$"\\LogDump_{DateTime.Now.Date.ToString($"dd_MM_yy")}.txt";
Logs.WriteToLogFile(dumpDirectory, MyErrorLogs);
Logs.WriteToLogFile(dumpDirectory, MyRequestLogs);
await e.User.SendMessage($"All logs have been dumped.");
});
});
}
