public UserState GetTargetUserState(CommandEventArgs e)
{
User usr = e.Channel.Users.FirstOrDefault(u => u.Name == e.GetArg("target"));
if (usr != null)
{
if (Beta.UserStateRepository.VerifyUsersExists(usr.Id))
{
var target = Beta.UserStateRepository.GetUserState(usr.Id);
if (target.RPGHitpoints == -1)
{
target.RPGHitpoints = target.RPGMaxHP;
}
return(target);
}
}
if (Beta.UserStateRepository.VerifyNPCExists(e.GetArg("target")))
{
var target =
Beta.UserStateRepository.NPCUserStates.FirstOrDefault(nu => nu.UserName == e.GetArg("target"));
Console.WriteLine("Target is null : " + (target == null));
return(target);
}
return(null);
}
private async Task SearchDestinyPlayer(CommandEventArgs e)
{
try {
e.Channel.SendIsTyping();
MembershipType memtype;
if (!ParsePlatform(e.GetArg("platform"), out memtype))
{
await _client.ReplyError(e, "Invalid platform provided. Must be `psn` or `xbox`.");
return;
}
var bongi = await _bungie.SearchDestinyPlayer(memtype, e.GetArg("displayName"));
var reply = new StringBuilder();
foreach (var hit in bongi)
{
reply.Append($"{hit.displayName}: {hit.membershipId}")
.AppendLine();
}
await e.Channel.SendMessage(reply.ToString());
} catch (Exception ex) {
Console.WriteLine(ex);
await _client.ReplyError(e, ex);
}
}
private async Task AddCommand(CommandEventArgs e)
{
e.Channel.SendIsTyping();
var com = new CustomCommands.Command {
CommandName = e.GetArg("name"),
CommandContent = e.GetArg("content"),
CreatorId = e.User.Id.ToString()
};
try {
await _custom.AddCommand(com);
commands = (await _custom.GetCommands()).ToList();
await e.Channel.SendMessage($"Command `{com.CommandName}` created.");
} catch (Exception ex) {
if (ex is CustomCommClient.CommandExistsException)
{
await e.Channel.SendMessage($"A command by the name `{com.CommandName}` already exists.");
}
else
{
await _client.ReplyError(e, $"Command couldn't be created: ```{ex.ToString()}```");
}
return;
}
}
static async Task Dice(CommandEventArgs args)
{
string maxString = args.GetArg("max");
string minString = args.GetArg("min");
int max = 6;
int min = 1;
if (maxString != null)
{
if (!int.TryParse(maxString, out max))
{
throw new InvalidCommandArgumentException("Le maximum doit être un entier valide");
}
}
if (minString != null)
{
if (!int.TryParse(minString, out min))
{
throw new InvalidCommandArgumentException("Le minimum doit être un entier valide");
}
}
if (max < min)
{
int temp = max;
max = min;
min = temp;
}
await args.Channel.SendMessage(Bot.rand.Next(min, max).ToString());
}
private async Task FinishClaim(CommandEventArgs e, int stars = 3)
{
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, stars);
await e.Channel.SendMessage($"❗🔰{e.User.Mention} **DESTROYED** a base #{baseNum + 1} in a war against {war.ShortPrint()}").ConfigureAwait(false);
Save();
}
catch (Exception ex)
{
await e.Channel.SendMessage($"💢🔰 {ex.Message}").ConfigureAwait(false);
}
}
//Adds question
async internal static Task Add(CommandEventArgs e)
{
RuntimeStatics.Questions.Add(e.GetArg("Question"));
await e.Channel.SendMessage($"Added Question {e.GetArg("Question")} at ID {RuntimeStatics.Questions.Count}");
SaveQuestions();
}
//Moves a question to the specified location
async internal static Task MoveTo(CommandEventArgs e)
{
int FirstID, SecondID;
var questions = RuntimeStatics.Questions;
if (int.TryParse(e.GetArg("FirstID"), out FirstID) && int.TryParse(e.GetArg("SecondID"), out SecondID))
{
if (FirstID > 0 && FirstID <= questions.Count && SecondID > 0 && SecondID <= questions.Count)
{
var q = questions.ElementAt(FirstID - 1);
RuntimeStatics.Questions.RemoveAt(FirstID - 1);
RuntimeStatics.Questions.Insert(SecondID - 1, q);
SaveQuestions();
await e.Channel.SendMessage($"Moved question ID {FirstID} to {SecondID}");
}
else
{
await e.Channel.SendMessage("ID was out of range. Please enter numbers within the current range of questions.");
}
}
else
{
await e.Channel.SendMessage($"{e.GetArg("FirstID")} or {e.GetArg("SecondID")} is not a valid integers");
}
}
public async void runCommand(CommandEventArgs command)
{
if (command.Args.Length == 0)
{
await command.Channel.SendMessage(command.Message.User.NicknameMention + " needs a argument for that command");
}
else if (!methods.ContainsKey(command.GetArg(0)))
{
if (command.Args.Length == 1 && conversational)
{
await methods[""](command);
}
else
{
await command.Channel.SendMessage(command.GetArg(0) + " is not an command");
}
}
else
{
try
{
await methods[command.GetArg(0)](command);
}catch (Exception e)
{
error(e, command);
}
}
}
private async Task RemoveCommand(CommandEventArgs e)
{
e.Channel.SendIsTyping();
if (!commands.Exists(x => x.CommandName == e.GetArg("name")))
{
await e.Channel.SendMessage("Provided command doesn't exist.");
return;
}
var com = commands.Find(x => x.CommandName == e.GetArg("name"));
if (com.CreatorId != e.User.Id.ToString() &&
!e.User.ServerPermissions.ManageServer)
{
await e.Channel.SendMessage("You are not the creator of this command, or do not have the Manage Server permission. Command not removed.");
return;
}
try {
await _custom.RemoveCommand(com);
commands.Remove(com);
//CreateCommands(_manager);
await e.Channel.SendMessage("Command removed.");
} catch (Exception ex) {
await e.Channel.SendMessage($"Command couldn't be removed: ```{ex.ToString()}```");
}
}
private static Tuple <List <ClashWar>, int> GetInfo(CommandEventArgs e)
{
//check if there are any wars
List <ClashWar> wars = null;
ClashWars.TryGetValue(e.Server.Id, out wars);
if (wars == null || wars.Count == 0)
{
return(null);
}
// get the number of the war
int num;
if (string.IsNullOrWhiteSpace(e.GetArg("number")))
{
num = 0;
}
else if (!int.TryParse(e.GetArg("number"), out num) || num > wars.Count)
{
return(null);
}
num -= 1;
//get the actual war
return(new Tuple <List <ClashWar>, int>(wars, num));
}
public bool ValidChatBattleTarget(CommandEventArgs e)
{
bool userExists = e.Channel.Users.FirstOrDefault(u => u.Name == e.GetArg("target")) != null;
bool npcExists = Beta.UserStateRepository.NPCUserStates.FirstOrDefault(u => u.UserName == e.GetArg("target")) != null;
return(userExists || npcExists);
}
public async Task RemoveRole(CommandEventArgs e)
{
string message = RoleManager.RemoveRole(e.GetArg(CommandsConstants.ParameterDiscordRole), (long)e.Server.Id) ?
SettingsModuleResource.RoleDisconnected : SettingsModuleResource.RoleCantDsiconnect;
await SendStyleMessage(e.Channel, message, SettingsModuleResource.Markdown);
}
public async Task Unmute(CommandEventArgs e)
{
var user = e.Server.FindUsers(e.GetArg(Constants.ParameterUserName)).FirstOrDefault();
if (user == null)
{
await SendStyleMessage(e.Channel, Strings.UserNotExist);
return;
}
if (!e.Server.FindRoles(Constants.MuteRoleName).Any())
{
await e.Server.CreateRole(Constants.MuteRoleName, Discord.ServerPermissions.None, Discord.Color.DarkGrey);
}
var muteRole = e.Server.FindRoles(Constants.MuteRoleName).FirstOrDefault();
if (muteRole == null)
{
return;
}
if (user.HasRole(muteRole))
{
await user.RemoveRoles(muteRole);
}
await SendStyleMessage(e.Channel, String.Format(Strings.UserUnmuted, user.Name));
}
public async Task Mute(CommandEventArgs e)
{
var user = e.Server.FindUsers(e.GetArg(Constants.ParameterUserName)).FirstOrDefault();
if (user == null)
{
await SendStyleMessage(e.Channel, Strings.UserNotExist);
return;
}
if (!e.Server.FindRoles(Constants.MuteRoleName).Any())
{
var role = await e.Server.CreateRole(Constants.MuteRoleName, Discord.ServerPermissions.None, Discord.Color.DarkGrey);
foreach (var channel in e.Server.TextChannels)
{
await channel.AddPermissionsRule(role, Discord.ChannelPermissions.None, Discord.ChannelPermissions.All(channel));
}
}
await user.RemoveRoles(user.Roles.ToArray());
await user.AddRoles(e.Server.FindRoles(Constants.MuteRoleName).First());
await SendStyleMessage(e.Channel, String.Format(Strings.UserMuted, user.Name));
}
private async Task CharacterOverview(CommandEventArgs e)
{
try {
e.Channel.SendIsTyping();
MembershipType memtype;
if (!ParsePlatform(e.GetArg("platform"), out memtype))
{
await _client.ReplyError(e, "Invalid platform provided. Must be `psn` or `xbox`.");
return;
}
var result = (await _bungie.SearchDestinyPlayer(memtype, e.GetArg("displayName"))).First();
string id = result.membershipId;
if (String.IsNullOrWhiteSpace(id))
{
await _client.ReplyError(e, $"No player by name `{e.GetArg("displayName")}` found.");
return;
}
var membership = await _bungie.GetAccountSummary(memtype, id);
var answer = new StringBuilder();
string clan;
//if (String.IsNullOrWhiteSpace(membership.ClanName)) {
// clan = $", *{membership.ClanName}*";
//} else {
clan = String.Empty;
//}
answer.Append($"{result.displayName}{clan}: ")
.AppendLine();
answer.Append($"Last played: {membership.Characters.First().Base.DateLastPlayed.ToShortDateString()} {membership.Characters.First().Base.DateLastPlayed.ToShortTimeString()}")
.AppendLine();
foreach (var character in membership.Characters)
{
answer.Append(" ")
.Append($"{character.Base.Race} {character.Base.Class} {character.Level}, Light: {character.Base.PowerLevel}")
.AppendLine();
}
await e.Channel.SendMessage(answer.ToString());
} catch (Exception ex) {
Console.WriteLine(ex);
await _client.ReplyError(e, ex);
}
}
public async Task RemoveFilter(CommandEventArgs e)
{
long id = Convert.ToInt64(e.GetArg(Constants.Id));
long guildId = (long)e.Server.Id;
FilterService.Instance.Repository.RemoveFilterByGuildId(id, guildId);
await SendStyleMessage(e.Channel, Strings.FilterRemoved);
}
public async Task Log(CommandEventArgs args)
{
Console.ForegroundColor = ConsoleColor.DarkCyan;
Console.Write(args.User.Name + " (");
Console.Write(args.User.Id);
Console.Write(") - " + args.Channel.Name + ": ");
Console.ResetColor();
Console.WriteLine(args.GetArg("message"));
}
/// <summary>
/// Removes active trade offer from list by queue id
/// </summary>
/// <param name="e">CommandEventArgs</param>
public void OnDiscordRemoveOffer(CommandEventArgs e)
{
LockThreadsAndWait();
/*Remove all matching offers*/
int result = mActiveTradesList.RemoveAll(o => o.QueId == e.GetArg(0));
e.Channel.SendMessage($"Removed {result} active trade offers");
mSessionState = SessionState.Active;
}
static async Task Choose(CommandEventArgs args)
{
string[] values = args.GetArg("valeurs").Split(new char[] { ',' });
for (int i = 0; i < values.Length; i++)
{
values[i] = values[i].Trim();
}
await args.Channel.SendMessage(values[Bot.rand.Next(values.Length)]);
}
public async Task AddRole(CommandEventArgs e)
{
string discordRole = e.GetArg(CommandsConstants.ParameterDiscordRole);
string realRole = e.GetArg(CommandsConstants.ParameterRealRole);
try
{
CheckRole(e.Server.Roles, discordRole);
BotRoles botRole = ParseRole(realRole);
RoleManager.RemoveRole(discordRole, (long)e.Server.Id);
RoleManager.AddRole(discordRole, botRole, (long)e.Server.Id);
await SendStyleMessage(e.Channel, SettingsModuleResource.RolesConnected, SettingsModuleResource.Markdown);
}
catch (ArgumentException exp)
{
await SendStyleMessage(e.Channel,
String.Format(SettingsModuleResource.RoleIsNotExist, exp.Message),
SettingsModuleResource.Markdown);
}
}
private Channel GetVoiceChannel(CommandEventArgs args)
{
var userName = args.GetArg(ARG_USER);
if (string.IsNullOrEmpty(userName))
{
return(args.User.VoiceChannel);
}
var user = args.Server.FindUsers(userName, true).FirstOrDefault();
return(user?.VoiceChannel);
}
public async Task Ban(CommandEventArgs e)
{
var user = e.Server.FindUsers(e.GetArg(Constants.ParameterUserName)).FirstOrDefault();
if (user == null)
{
await SendStyleMessage(e.Channel, Strings.UserNotExist);
return;
}
await e.Server.Ban(user);
await SendStyleMessage(e.Channel, String.Format(Strings.UserBanned, user.Name));
}
public async Task genereateVsImage(CommandEventArgs args)
{
ulong otherId = 0;
if (Bot.TryGetIdFromMention(args.GetArg("other"), ref otherId))
{
await args.Channel.SendIsTyping();
User other = args.Channel.GetUser(otherId);
await args.Channel.SendFile(args.User.Name + "vs" + other.Name + ".png", GenerateVs2Image(args.User, other));
}
else
{
await args.Channel.SendMessage("Utilisateur invalide.");
}
}
private async Task SendViewMessage(CommandEventArgs e, Func <IComponent, long, bool> predicate)
{
try
{
CommandsManager manager = new CommandsManager((long)e.Server.Id, predicate);
string name = e.GetArg(CommandsConstants.ParameterModuleName);
string view = String.IsNullOrEmpty(name) ? manager.CreateComponentsView(mBotModulesObserver.Modules) :
manager.CreateComponentsView(CommandsManager.FindModule(name, mBotModulesObserver.Modules));
await SendStyleMessage(e.Channel, view, SettingsModuleResource.Css);
}
catch (ArgumentException exp)
{
await SendExceptonMessage(e.Channel, exp);
}
}
static async Task AddGame(CommandEventArgs args)
{
string gamename = args.GetArg("gamename");
if (!gamesList.Contains(gamename))
{
string[] newGameList = new string[gamesList.Length + 1];
gamesList.CopyTo(newGameList, 0);
newGameList[gamesList.Length] = gamename;
gamesList = newGameList;
SaveLine(gameFileName, gamename);
await args.Channel.SendMessage("Le jeu " + gamename + " à été ajouté.");
BotDebug.Log("A game has been added (" + gamename + ")");
}
}
public async Task AddFilter(CommandEventArgs e)
{
string pattern = e.GetArg(Constants.Regex);
long guildId = (long)e.Server.Id;
if (IsValidRegex(pattern))
{
FilterService.Instance.Repository.Add(new Filter {
GuildId = guildId, Regex = pattern
});
await SendStyleMessage(e.Channel, String.Format(Strings.FilterAdded, pattern));
}
else
{
await SendStyleMessage(e.Channel, String.Format(Strings.IsNotValidRegex, pattern));
}
}
static async Task Roast(CommandEventArgs args)
{
if (args.Server.Id == 210360089318522880ul)
{
await args.Channel.SendMessage("Commande désactivée dans ce sereur pour en respecter le climat pédagogique ¯\\_(ツ)_/¯");
return;
}
string target = args.GetArg("cible");
string targetName = "qqn";
if (target == null)
{
if (args.Channel.IsPrivate)
{
targetName = args.User.Name;
}
else
{
User[] users = args.Server.Users.Where((u) => (u.Status != UserStatus.Offline)).ToArray();
targetName = Bot.getUserName(users[Bot.rand.Next(users.Length)]);
}
}
else if (target.ToLower() == "me")
{
targetName = args.User.Name;
}
else
{
ulong id = 0;
if (Bot.TryGetIdFromMention(target, ref id))
{
targetName = Bot.getUserName(args.Server.GetUser(id));
}
else
{
targetName = target;
}
}
int chosenRoast = Bot.rand.Next(roastsList.Length);
string roast = String.Format(roastsList[chosenRoast], targetName);
BotDebug.OnRoast(chosenRoast);
await args.Channel.SendMessage(roast);
}
static async Task Color(CommandEventArgs args)
{
User user = args.User;
string colorName = args.GetArg("colorname").ToLower();
if (args.Channel.IsPrivate)
{
await args.Channel.SendMessage("Impossible de changer la couleur dans une cenversation privée.");
}
else if (colorRoles.Contains(colorName))
{
await user.RemoveRoles(getUserColorRoles(user));
await Task.Delay(750);
foreach (Role r in args.Server.Roles)
{
if (r.Name.ToLower() == colorName)
{
await Bot.botInstance.DiscordClient.GetServer(args.Server.Id).GetUser(user.Id).AddRoles(r);
}
}
}
else if (colorName == "default")
{
await user.RemoveRoles(getUserColorRoles(user));
}
else
{
StringBuilder builder = new StringBuilder("Veuillez entrer une couleur valide (");
for (int i = 0; i < colorRoles.Length; i++)
{
if (i != 0)
{
builder.Append(", ");
}
builder.Append(colorRoles[i]);
}
builder.Append(") ou 'default' pour avoir la couleur de base.");
await args.Channel.SendMessage(builder.ToString());
}
}
public override async Task ExecuteAsync(CommandEventArgs args)
{
var sound = args.GetArg(ARG_FILE);
var file = _soundRepository.GetSoundFile(sound);
if (null == file)
{
await SendMessageToChannelAsync(args, $"Sound '{sound}' does not exist");
return;
}
var voiceChannel = GetVoiceChannel(args);
if (null == voiceChannel)
{
await SendMessageToChannelAsync(args, "No voice channel could be found");
return;
}
await _player.PlayAsync(new DiscordChannel(voiceChannel), file.Path);
}
public async Task Calculate(CommandEventArgs e)
{
string expr = e.GetArg(CommandsConstants.Expression);
try
{
double result = RichardCalculator.Calculate(expr);
await SendStyleMessage(e.Channel, String.Format(SettingsModuleResource.ExpressionResult, expr, result), SettingsModuleResource.Markdown);
}
catch (LexicalException exp)
{
await SendStyleMessage(e.Channel, String.Format(SettingsModuleResource.LexicalException, expr, exp.Message), SettingsModuleResource.Markdown);
}
catch (SyntaxException exp)
{
await SendStyleMessage(e.Channel, String.Format(SettingsModuleResource.SyntaxException, expr, exp.Message), SettingsModuleResource.Markdown);
}
catch (Exception exp)
{
await SendStyleMessage(e.Channel, String.Format(SettingsModuleResource.Exception, expr, exp.Message), SettingsModuleResource.Markdown);
}
}
