public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
if (Constants.IsBotOwner(args.UserId))
{
Task.Run(async() =>
{
string name = command.CommandDetail;
if (args.ChannelId != Constants.ConsoleId)
{
var guild = await client.GetGuildAsync(args.GuildId).ConfigureAwait(false);
var user = guild.GetUser(client.CurrentUser.Id);
await user.ModifyAsync(x => x.Nickname = name).ConfigureAwait(false);
}
else
{
Console.Title = name;
}
});
return(new Response[] { Response.CreateFromReact(Emojis.ThumbsUpUnicode) });
}
else
{
return(Response.CreateArrayFromString($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(serverSettings.Language, "Error_BotOwnerOnly")}."));
}
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
return(Response.CreateArrayFromString(AddZalgo(command.CommandDetail)));
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
Response response = new Response
{
Embed = EmbedUtility.ToEmbed(Help),
Message = Help,
ResponseType = ResponseType.Default
};
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string commandDetail = command.CommandDetail;
response = waitHandler.CreatePleaseWaitResponse(senderDetail.ServerSettings.Language);
Task.Run(async() =>
{
Response asyncResponse = await BuildMemeAsync(senderDetail.ServerSettings.Language, args);
if (asyncResponse == null)
{
string err = ($"{Emojis.NoEntry} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_NoImageMessages")}");
asyncResponse = new Response
{
Embed = EmbedUtility.ToEmbed(err),
Message = err,
ResponseType = ResponseType.Default
};
}
await asyncResponder.SendResponseAsync(args, asyncResponse);
waitHandler.PopPleaseWaitMessage();
});
return(new[] { response });
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
// First, substitute the variables.
string message = VariableStrings.Replace(command.CommandDetail, args.Username, args.UserId.ToString(), args.GuildName, command.CommandDetail);
if (string.IsNullOrWhiteSpace(message))
{
// Use the command's name instead.
message = command.FullCommandExcludingCommandPrefix;
}
// Shrug.
message = message.StripAccents();
// Now substitute the replacements from the table.
StringBuilder sb = new StringBuilder();
foreach (char c in message)
{
string letter = c.ToString();
foreach (var replacementPair in replaceTable)
{
letter = letter.Replace(replacementPair.Key, replacementPair.Value, (ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal));
// If a replacement was made.
if (letter != c.ToString())
{
break;
}
}
sb.Append(letter);
}
string output = reverse ? new string(sb.ToString().Reverse().ToArray()) : sb.ToString();
List <Response> responses = new List <Response>
{
new Response
{
Embed = null,
Message = output,
ResponseType = ResponseType.Default
}
};
if (doTTS)
{
responses.Add(
new Response
{
Embed = null,
Message = output,
ResponseType = ResponseType.Default_TTS
}
);
}
return(responses.ToArray());
}
internal IList <Response> ExecuteCommand(SenderSettings senderDetail, IMessageDetail messageDetail)
{
List <Response> responses = new List <Response>();
CommandMessageHelper helper = new CommandMessageHelper(senderDetail.ServerSettings.CommandSymbol, messageDetail.Message);
Languages currentLanguage = senderDetail.ServerSettings.Language;
// If we're running default, assume English.
if (currentLanguage == Languages.Default)
{
currentLanguage = Languages.English;
}
if (helper.IsCommand || messageDetail.IsPrivate)
{
// Check language specific commands.
foreach (Command command in commands[currentLanguage])
{
if (command.Aliases.Contains(helper.CommandLower, StringComparer.OrdinalIgnoreCase) || command.NoSetAlias)
{
responses.AddRange(command.Execute(senderDetail, messageDetail));
}
}
// Then check defaults.
foreach (Command command in commands[Languages.Default])
{
if (command.Aliases.Contains(helper.CommandLower, StringComparer.OrdinalIgnoreCase) || command.NoSetAlias)
{
responses.AddRange(command.Execute(senderDetail, messageDetail));
}
}
}
else
{
// Check only commands that do not require a command symbol.
// Check language specific commands.
foreach (Command command in commands[currentLanguage].Where(c => !c.RequiresSymbol))
{
if (command.Aliases.Contains(helper.CommandLower, StringComparer.OrdinalIgnoreCase) || command.NoSetAlias)
{
responses.AddRange(command.Execute(senderDetail, messageDetail));
}
}
// Then check defaults.
foreach (Command command in commands[Languages.Default].Where(c => !c.RequiresSymbol))
{
if (command.Aliases.Contains(helper.CommandLower, StringComparer.OrdinalIgnoreCase) || command.NoSetAlias)
{
responses.AddRange(command.Execute(senderDetail, messageDetail));
}
}
}
return(responses);
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string requestStr = command.CommandDetail;
ulong requestedId;
if (string.IsNullOrWhiteSpace(requestStr))
{
// Default to the user asking.
requestedId = args.UserId;
}
else
{
// Parse a mention?
if (requestStr.StartsWith("<@") && requestStr.EndsWith(">"))
{
requestStr = requestStr.Substring("<@".Length, requestStr.Length - 3); // Minus 3 for <@nnnnn>
}
// Id?
if (!ulong.TryParse(requestStr, out requestedId))
{
// No, fail.
return(Response.CreateArrayFromString($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_NoResults")}: {requestStr}"));
}
}
if (client != null)
{
Task.Run(async() =>
{
// From the id, determine if it's a user or server.
// Is it a server?
var candidateServer = await client.GetGuildAsync(requestedId).ConfigureAwait(false);
if (candidateServer != null)
{
await asyncResponder.SendResponseAsync(args, Response.CreateFromString($"{candidateServer.IconUrl}")).ConfigureAwait(false);
}
// Is it a channel?
IChannel candidateChannel = await client.GetDMChannelAsync(requestedId).ConfigureAwait(false);
if (candidateChannel != null)
{
await asyncResponder.SendResponseAsync(args, Response.CreateFromString($"{candidateChannel.GetGuild().IconUrl}")).ConfigureAwait(false);
}
// Is it a user?
IUser candidateUser = client.GetUser(requestedId);
if (candidateUser != null)
{
await asyncResponder.SendResponseAsync(args, Response.CreateFromString($"{candidateUser.GetAvatarUrl(ImageFormat.Auto, 2048)}")).ConfigureAwait(false);
}
});
}
return(new Response[] { Response.WaitForAsync });
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
StringBuilder sb = new StringBuilder();
string charArray = command.CommandDetail.StripAccents();
int length = charArray.Length;
if (length > 80)
{
string err = ($"{Emojis.NoEntry} {languageHandler.GetPhrase(serverSettings.Language, "Error_NotAFile")}");
sb.AppendLine(err);
}
else
{
sb.AppendLine();
foreach (char c in charArray)
{
if (char.IsLetterOrDigit(c))
{
sb.Append(":regional_indicator_").Append(char.ToLowerInvariant(c)).Append(": ");
}
else if (c == ' ')
{
sb.Append(":blue_heart: ");
}
else if (c == '!')
{
sb.Append(":grey_exclamation: ");
}
else if (c == '?')
{
sb.Append(":grey_question: ");
}
else if (c == '\'')
{
sb.Append(":arrow_down_small: ");
}
else
{
sb.Append(c);
}
}
sb.AppendLine();
foreach (char _ in charArray)
{
sb.Append(Emojis.CheerleaderSymbols[rand.Next(0, Emojis.CheerleaderSymbols.Count)]).Append(' ');
}
}
return(Response.CreateArrayFromString(sb.ToString()));
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string responseMessage;
if (Constants.IsBotOwner(args.UserId))
{
string channelIdStr = command.CommandParams[1];
if (!string.IsNullOrWhiteSpace(channelIdStr))
{
bool parsed = ulong.TryParse(channelIdStr, out ulong targetChannelId);
if (parsed)
{
string messageToSend = string.Join(" ", command.CommandParams, 2, command.CommandParams.Length - 2);
if (string.IsNullOrEmpty(messageToSend))
{
responseMessage = ($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_IncorrectParameter")}: say <channel id> <message> -- message");
}
else
{
if (asyncResponder.SendResponse(targetChannelId, Response.CreateFromString(messageToSend)))
{
responseMessage = ($"{Emojis.TickSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "YourRequestHasBeenSent")}: {messageToSend} --> {channelIdStr}");
}
else
{
responseMessage = ($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_NoResults")}: {channelIdStr}");
}
}
}
else
{
responseMessage = ($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_IncorrectParameter")}: say <channel id> <message> -- {channelIdStr}");
}
}
else
{
responseMessage = $"{Emojis.CrossSymbol} say <channel id> <message>.";
}
}
else
{
responseMessage = $"{Emojis.CrossSymbol} {languageHandler.GetPhrase(serverSettings.Language, "Error_BotOwnerOnly")}.";
}
return(Response.CreateArrayFromString(responseMessage));
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
StringBuilder retVal = new StringBuilder();
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string[] commandParams = command.CommandParams;
Command[] commands = commandController.GetCommandsForLanguage(senderDetail.ServerSettings.Language);
Discord.Color responseColor = Discord.Color.Green;
if (string.IsNullOrWhiteSpace(command.CommandDetail))
{
var commandsByModule = commands.GroupBy(x => x.Module).ToDictionary(grouping => grouping.Key, grouping => grouping.ToList());
foreach (var pair in commandsByModule)
{
retVal.Append("**");
retVal.Append(pair.Key.ToString());
retVal.AppendLine("**");
retVal.AppendLine(string.Join(", ", pair.Value.Select(c => c.Aliases[0])));
retVal.AppendLine();
}
}
else
{
string search = command.CommandArgs.First().ToLowerInvariant();
Command found = commands.FirstOrDefault(c => c.Aliases.Contains(search, StringComparer.OrdinalIgnoreCase));
if (found != null)
{
retVal.AppendLine(found.Help + "\r\n" + found.Examples);
}
else
{
retVal.AppendLine($"{Emojis.QuestionSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_IncorrectParameter")}");
responseColor = Discord.Color.Red;
}
}
string message = retVal.ToString();
Response response = new Response
{
Embed = Utility.EmbedUtility.ToEmbed(message, responseColor),
Message = message,
ResponseType = ResponseType.Default
};
return(new[] { response });
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string choice = choices[rand.Next(choices.Length)];
string result = VariableStrings.Replace(choice, args.Username, args.UserId.ToString(), args.GuildName, command.CommandDetail);
Response response = new Response
{
Embed = null,
Message = result,
ResponseType = responseType
};
return(new[] { response });
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
UserSettings userSettings = senderDetail.UserSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string[] commandParams = command.CommandParams;
var allAchievements = SaveData.Achievements.Achievement.AllAchievements;
var unlockedAchievements = userSettings.UserStats.GetAchievements();
// First, reply to the room that the command was written in.
// This has minimal information so as to not spoil achievements
// for other users.
string outputToChannel = ($"{languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Achievements_AchievementsUnlocked")}: {unlockedAchievements.Count}/{allAchievements.Count} {Emojis.Trophy}");
Response channelResponse = new Response
{
Embed = Utility.EmbedUtility.ToEmbed(outputToChannel, 200, 200, 50),
ResponseType = ResponseType.Default
};
// Next, PM the user their achievements and any still to unlock.
StringBuilder sb = new StringBuilder();
foreach (var achievement in allAchievements)
{
if (achievement.HasAchieved(userSettings.UserStats))
{
sb.AppendLine($"{Emojis.Trophy} {achievement.GetDescription(languageHandler, senderDetail.ServerSettings.Language)}");
}
else
{
sb.AppendLine($"???");
}
}
string outputToPrivate = sb.ToString();
Response privateResponse = new Response
{
Embed = Utility.EmbedUtility.ToEmbed(outputToPrivate, 200, 200, 50),
ResponseType = ResponseType.Private
};
return(new[] { channelResponse, privateResponse });
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
StringBuilder choice = new StringBuilder(choiceFormat);
for (int i = 0; i < choices.Length; i++)
{
choice.Replace($"{{{i}}}", choices[i][rand.Next(choices[i].Length)]);
}
string result = VariableStrings.Replace(choice, args.Username, args.UserId.ToString(), args.GuildName, command.CommandDetail).ToString();
Response response = new Response
{
Embed = null,
Message = result,
ResponseType = responseType
};
return(new[] { response });
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
StringBuilder sb = new StringBuilder();
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string commandDetail = command.CommandDetail;
// Split by or delimiter, not space.
if (command.FullCommandExcludingCommandPrefix.ToLowerInvariant().Contains(delimiter))
{
string[] orChoices = commandDetail.Split(delimiter);
if (!orChoices.Any())
{
sb.AppendLine($"{command.CommandSymbol}{command.CommandLower} A{delimiter}B{delimiter}C...");
}
else
{
sb.AppendLine(orChoices[rand.Next(orChoices.Length)].Trim());
sb.Append("_").Append(languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "IgnoredOr")).Append("_");
}
}
// Else split by space
else
{
string[] choices = command.CommandArgs.ToArray();
if (!choices.Any())
{
sb.AppendLine($"{command.CommandSymbol}{command.CommandLower} A B C ...");
}
else
{
sb.AppendLine(choices[rand.Next(choices.Length)]);
}
}
return(Response.CreateArrayFromString(sb.ToString()));
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string[] commandParams = command.CommandParams;
if (Constants.IsBotOwner(args.UserId))
{
var servers = (client.Guilds).ToArray();
string serverOutputString = string.Join("\n ",
servers.Select((server) =>
{
var ss = serverSettingsHandler.GetOrCreateServerSettings(server.Id);
var owner = server.Owner;
return($"`{server.Name}` ({ss.Language}): `{owner?.Username}`");
}));
return(Response.CreateArrayFromString(servers.Length + " servers: \n" + serverOutputString));
}
return(Response.CreateArrayFromString($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(serverSettings.Language, "Error_BotOwnerOnly")}."));
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
Discord.Color responseColor;
string message;
if (ImageManipulator.FindHexColour(command.CommandDetail, out string foundColour))
{
var color = ImageManipulator.FromHexCode(foundColour);
responseColor = new Discord.Color(color.R, color.G, color.B);
var knownColor = color.ToKnownColor();
message = knownColor != 0 ? $"✓ {knownColor}" : $"(~) {color.ToConsoleColor()}";
}
else if (Enum.TryParse(command.CommandDetail, true, out KnownColor knownColor))
{
var color = Color.FromKnownColor(knownColor);
responseColor = new Discord.Color(color.R, color.G, color.B);
message = $"✓ {knownColor}";
}
else
{
responseColor = Discord.Color.Default;
message = $"{Emojis.QuestionSymbol} {command.CommandDetail}";
}
Response response = new Response
{
Embed = Utility.EmbedUtility.ToEmbed(message, responseColor),
Message = message,
ResponseType = ResponseType.Default
};
return(new[] { response });
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
string retVal = "";
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string[] commandParams = command.CommandParams;
ushort flips;
Discord.Color responseColor = new Discord.Color(0);
if (commandParams.Length == 1)
{
flips = 1;
}
else
{
if (!ushort.TryParse(commandParams[1], out flips) || flips <= 0)
{
retVal = ($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(serverSettings.Language, Errors.ErrorCode.IncorrectParameter)}: {commandParams[1]}. [1-{uint.MaxValue}].");
}
}
if (flips > 0)
{
int heads = 0, tails = 0;
string localeHead = languageHandler.GetPhrase(serverSettings.Language, "CoinHead");
string localeTail = languageHandler.GetPhrase(serverSettings.Language, "CoinTail");
if (flips == 1)
{
switch (rand.Next(2))
{
default:
case 0: retVal = localeHead; heads++; break;
case 1: retVal = localeTail; tails++; break;
}
}
else
{
char headLetter = (localeHead)[0];
char tailLetter = (localeTail)[0];
string flipped = languageHandler.GetPhrase(serverSettings.Language, "Flipped");
if (flips > 100)
{
for (int i = 0; i < flips; i++)
{
switch (rand.Next(2))
{
case 0: heads++; break;
case 1: tails++; break;
}
}
retVal = ($"{flipped} {flips}x, `{localeHead}:` {heads}, `{localeTail}:` {tails}");
}
else
{
StringBuilder coinflips = new StringBuilder();
for (int i = 0; i < flips; i++)
{
switch (rand.Next(2))
{
case 0: coinflips.Append(headLetter); heads++; break;
case 1: coinflips.Append(tailLetter); tails++; break;
}
}
retVal = ($"{flipped} {flips}x, `{localeHead}:` {heads}, `{localeTail}:` {tails}: {coinflips.ToString()}");
}
}
if (heads < tails)
{
responseColor = new Discord.Color(200, 50, 50);
}
else if (heads > tails)
{
responseColor = new Discord.Color(50, 200, 50);
}
else
{
responseColor = new Discord.Color(200, 200, 50);
}
}
Response response = new Response
{
Embed = Utility.EmbedUtility.ToEmbed(retVal, responseColor),
Message = retVal,
ResponseType = ResponseType.Default
};
return(new[] { response });
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
StringBuilder output = new StringBuilder();
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string[] commandParams = command.CommandParams;
long min = 0;
long max;
if (commandParams.Length == 1)
{
max = 10;
}
else if (commandParams.Length == 2)
{
if (!long.TryParse(commandParams[1], NumberStyles.Any, CultureInfo.InvariantCulture, out max))
{
if (commandParams[1] == "∞" || commandParams[1].StartsWith("inf"))
{
max = long.MaxValue;
}
else if (commandParams[1] == "-∞" || commandParams[1].StartsWith("-inf"))
{
max = long.MinValue;
}
else
{
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(serverSettings.Language, Errors.ErrorCode.IncorrectParameter)}: {commandParams[1]}.");
max = 10;
}
}
}
else
{
if (!long.TryParse(commandParams[1], NumberStyles.Any, CultureInfo.InvariantCulture, out min))
{
if (commandParams[1] == "∞" || commandParams[1].StartsWith("inf"))
{
min = long.MaxValue;
}
else if (commandParams[1] == "-∞" || commandParams[1].StartsWith("-inf"))
{
min = long.MinValue;
}
else
{
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(serverSettings.Language, Errors.ErrorCode.IncorrectParameter)}: {commandParams[1]}.");
min = 0;
}
}
if (!long.TryParse(commandParams[2], NumberStyles.Any, CultureInfo.InvariantCulture, out max))
{
if (commandParams[2] == "∞" || commandParams[2].StartsWith("inf"))
{
max = long.MaxValue;
}
else if (commandParams[2] == "-∞" || commandParams[2].StartsWith("-inf"))
{
max = long.MinValue;
}
else
{
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(serverSettings.Language, Errors.ErrorCode.IncorrectParameter)}: {commandParams[2]}.");
max = 10;
}
}
}
if (min > max)
{
// Swap
long temp = max;
max = min;
min = temp;
}
long num = rand.NextLong(min, max == long.MaxValue ? long.MaxValue : max + 1);
output.AppendLine((min) + " -> " + (max) + ": " + num);
ulong range = (ulong)(max - min);
if (range == 0)
{
range = 1;
}
long normNum = (num - min);
float percentage = (((float)normNum) / range) * 360;
if (percentage > 360)
{
percentage = 360;
}
var drawingColour = Imaging.ImageManipulator.FromAHSB(255, percentage, 0.8f, 0.5f);
var responseColor = new Discord.Color(drawingColour.R, drawingColour.G, drawingColour.B);
string retVal = output.ToString();
Response response = new Response
{
Embed = Utility.EmbedUtility.ToEmbed(retVal, responseColor),
Message = retVal,
ResponseType = ResponseType.Default
};
return(new[] { response });
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
StringBuilder output = new StringBuilder();
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
bool handled = false;
string toParse = command.CommandLower;
string commandDetail = command.CommandDetail;
if (Aliases.Contains(toParse))
{
if (Regex.IsMatch(commandDetail, D_REGEX, RegexOptions.IgnoreCase | RegexOptions.CultureInvariant | RegexOptions.Compiled | RegexOptions.Multiline))
{
// Ignore the command entered because the full command is in the detail.
toParse = commandDetail;
}
else
{
// Convert the command into a d6 command.
string timesToRollStr = "1";
string adjustmentStr = "+0";
// If number of times to roll is specified.
if (!string.IsNullOrEmpty(commandDetail))
{
// If adjustments are specified.
if (commandDetail.Contains("-") || commandDetail.Contains("+"))
{
int index = commandDetail.LastIndexOf("+");
if (index == -1)
{
index = commandDetail.LastIndexOf("-");
}
if (index > 0)
{
adjustmentStr = commandDetail.Substring(index, commandDetail.Length - index).Trim();
timesToRollStr = commandDetail.Substring(0, index).Trim();
}
}
else
{
timesToRollStr = commandDetail;
}
}
toParse = $"{timesToRollStr}d6{adjustmentStr}";
}
}
else
{
// Parse the whole thing
toParse += " " + commandDetail;
}
if (Regex.IsMatch(toParse, D_REGEX, RegexOptions.IgnoreCase | RegexOptions.CultureInvariant | RegexOptions.Compiled | RegexOptions.Multiline))
{
handled = true;
string[] diceParams = toParse.Split('d', 'D');
string rollsStr = string.IsNullOrEmpty(diceParams[0]) ? "1" : diceParams[0];
string diceTypeStr = string.IsNullOrEmpty(diceParams[1]) ? "6" : diceParams[1];
string adjustmentStr = "0";
if (diceTypeStr.Contains("-") || diceTypeStr.Contains("+"))
{
int index = diceTypeStr.LastIndexOf("+");
if (index == -1)
{
index = diceTypeStr.LastIndexOf("-");
}
if (index > 0)
{
adjustmentStr = diceTypeStr.Substring(index, diceTypeStr.Length - index).Trim();
diceTypeStr = diceTypeStr.Substring(0, index).Trim();
}
}
bool validNumberOfRolls = ushort.TryParse(rollsStr, out ushort rolls);
bool validDiceType = byte.TryParse(diceTypeStr, out byte diceType) || diceTypeStr == "F" || diceTypeStr == "f";
bool validAdjustmentDice = int.TryParse(adjustmentStr, NumberStyles.Any, CultureInfo.InvariantCulture, out int adjustment);
if (validNumberOfRolls && validDiceType && validAdjustmentDice)
{
if (diceTypeStr == "F" || diceTypeStr == "f")
{
RollFudgeDice(rolls, adjustment, languageHandler, serverSettings.Language, ref output);
}
else
{
RollDice(rolls, diceType, adjustment, languageHandler, serverSettings.Language, ref output);
}
if (diceType == 1)
{
output.AppendLine($"_{languageHandler.GetPhrase(serverSettings.Language, "WhatDidYouExpect")}_");
}
}
else
{
if (!validNumberOfRolls)
{
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(serverSettings.Language, Errors.ErrorCode.IncorrectParameter)}: {rollsStr} [0-65535]");
}
if (!validDiceType)
{
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(serverSettings.Language, Errors.ErrorCode.IncorrectParameter)}: {diceTypeStr} [0-255]");
}
if (!validAdjustmentDice)
{
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(serverSettings.Language, Errors.ErrorCode.IncorrectParameter)}: {adjustmentStr} [+-F]");
}
}
}
if (handled)
{
string retVal = output.ToString();
Response response = new Response
{
Embed = Utility.EmbedUtility.ToEmbed(retVal),
Message = retVal,
ResponseType = ResponseType.Default
};
return(new[] { response });
}
else
{
// Not handled.
return(Response.NoResponse);
}
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
// Verify command.
string[] splitCommand = command.CommandLower.Split('>', StringSplitOptions.RemoveEmptyEntries);
if (splitCommand.Length == 2)
{
var sourceLanguage = splitCommand[0];
if (!translateCodes.Contains(sourceLanguage))
{
if (string.Equals(sourceLanguage, "?") || sourceLanguage.Equals("auto", StringComparison.OrdinalIgnoreCase))
{
sourceLanguage = "auto";
}
else
{
// If the source language is not found, then assume the command is not for us.
return(Response.NoResponse);
}
}
// Command verified, continue with the translation.
var targetLanguage = splitCommand[1];
var toTranslate = command.CommandDetail;
if (string.IsNullOrWhiteSpace(toTranslate))
{
return(Response.CreateArrayFromString(TRANSLATE_HOMEPAGE));
}
else if (!translateCodes.Contains(targetLanguage))
{
string err = ($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_IncorrectParameter")}: {targetLanguage}");
return(Response.CreateArrayFromString(err));
}
string query = Uri.EscapeDataString(toTranslate);
string request =
"https://translate.googleapis.com/translate_a/single?client=gtx&dt=t"
+ $"&ie=UTF-8"
+ $"&oe=UTF-8"
+ $"&sl={sourceLanguage}"
+ $"&tl={targetLanguage}"
+ $"&q={query}";
errorLogger.LogDebug(request, false);
// Responds asynchronously.
Task.Run(async() =>
{
JContainer json;
string message = null;
try
{
json = (JContainer)await JSONHelper.GetJsonAsync(request).ConfigureAwait(false);
}
catch (Exception)
{
json = null;
message = ($"{Emojis.NoEntry} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_ServerNotFound")}");
}
try
{
dynamic outer = json[0];
if (outer.Count > 0)
{
StringBuilder translation = new StringBuilder();
for (int i = 0; i < outer.Count; i++)
{
string translatedLine = outer[i][0]?.ToString();
if (translatedLine != null)
{
translation.AppendLine(translatedLine);
}
}
if (translation.Length <= 0)
{
message = ($"{Emojis.Warning} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_NoResults")}");
}
else
{
message = translation.ToString();
}
}
else
{
message = ($"{Emojis.Warning} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_NoResults")}");
}
}
catch (Microsoft.CSharp.RuntimeBinder.RuntimeBinderException ex)
{
// Extra information for debugging.
errorLogger.LogException(ex, ErrorSeverity.Error);
errorLogger.LogDebug("Unable to process the translation response: " + ex, true);
errorLogger.LogDebug("Request: " + request, true);
errorLogger.LogDebug("Response: " + json, true);
// Let the usual error handling kick in.
throw;
}
Response asyncResponse = Response.CreateFromString(message);
await asyncResponder.SendResponseAsync(args, asyncResponse).ConfigureAwait(false);
});
// Return out the lifecycle with no response.
return(new[] { Response.WaitForAsync });
}
else
{
return(Response.NoResponse);
}
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string query = command.CommandDetail;
// Responds asynchronously.
Task.Run(async() =>
{
JContainer json;
string message = null;
string weapon = Splatoon.SplatoonDefs.TryFindWeapon(query);
if (weapon != null)
{
try
{
string buildsQuery = $@"query {{
searchForBuilds(weapon: ""{weapon}"")
{{
headgear
clothing
shoes
}}
}}";
string builtUrl = $"{url}?query={Uri.EscapeUriString(buildsQuery)}";
json = (JContainer)JsonConvert.DeserializeObject(await RequestsHelper.CurlGetCommand(builtUrl, origin).ConfigureAwait(false));
}
catch (Exception ex)
{
json = null;
message = ($"{Emojis.NoEntry} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_ServerNotFound")}");
Console.WriteLine(ex);
}
try
{
dynamic jsonResult = json["data"]["searchForBuilds"];
int count = 0;
foreach (var node in jsonResult)
{
JArray headgear = node["headgear"];
JArray clothing = node["clothing"];
JArray shoes = node["shoes"];
string[] mains = new string[] { headgear[0].ToString(), clothing[0].ToString(), shoes[0].ToString() };
List <string> subs = new List <string>();
subs.AddRange(headgear.Skip <JToken>(1).Values <string>());
subs.AddRange(clothing.Skip <JToken>(1).Values <string>());
subs.AddRange(shoes.Skip <JToken>(1).Values <string>());
var mainsDict = new Dictionary <string, int>(mains.GroupBy(x => x).ToDictionary(x => x.Key, x => x.Count()).OrderByDescending(pair => pair.Value));
var subsDict = new Dictionary <string, int>(subs.GroupBy(x => x).ToDictionary(x => x.Key, x => x.Count()).OrderByDescending(pair => pair.Value));
StringBuilder sb = new StringBuilder();
foreach (var pair in mainsDict)
{
sb.Append(pair.Value).Append("m");
if (subsDict.ContainsKey(pair.Key))
{
sb.Append(pair.Value).Append("s");
subsDict.Remove(pair.Key);
}
sb.Append(" ").Append(pair.Key).Append(", ");
}
foreach (var pair in subsDict)
{
sb.Append(pair.Value).Append("s");
sb.Append(" ").Append(pair.Key).Append(", ");
}
sb.AppendLine();
message += sb.ToString();
count++;
if (count > 6)
{
break;
}
}
}
catch (Exception ex)
{
message = ($"{Emojis.NoEntry} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_Oops")}");
Console.WriteLine(ex);
}
}
else
{
message = ($"{Emojis.QuestionSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_NoResults")}");
}
Response asyncResponse = new Response
{
ResponseType = ResponseType.Default,
Embed = EmbedUtility.ToEmbed(message, null),
Message = message
};
await asyncResponder.SendResponseAsync(args, asyncResponse);
});
// Return out the lifecycle with no response.
return(new[] { Response.WaitForAsync });
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string query = command.CommandDetail;
StringBuilder output = new StringBuilder();
try
{
const string url = "https://wiki.teamfortress.com/wiki/Crafting";
const string urlRaw = url + "?action=raw";
if (cachedText == null)
{
cachedText = WebHelper.GetText(urlRaw);
}
string rawText = cachedText;
// First we need to decide on what we're searching for.
bool multiLookup =
(!query.Contains("Fabricate", StringComparison.OrdinalIgnoreCase) &&
!query.Contains("Smelt", StringComparison.OrdinalIgnoreCase) &&
!query.Contains("Combine", StringComparison.OrdinalIgnoreCase));
if (multiLookup)
{
query = "Fabricate " + query;
}
bool querySatisfied = rawText.ContainsIgnore(query, StringComparison.OrdinalIgnoreCase, " ", "_", "-", ".");
if (!querySatisfied && multiLookup)
{
query = "Smelt " + query;
querySatisfied = rawText.ContainsIgnore(query, StringComparison.OrdinalIgnoreCase, " ", "_", "-", ".");
}
if (!querySatisfied && multiLookup)
{
query = "Combine " + query;
querySatisfied = rawText.ContainsIgnore(query, StringComparison.OrdinalIgnoreCase, " ", "_", "-", ".");
}
if (!querySatisfied)
{
string error = ($"{Emojis.ExclamationSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_UnknownRecipe")}");
output.AppendLine(error + " " + query + ": " + url);
}
else
{
// We're in business.
TextParser parser = new TextParser(rawText);
parser.MovePast(query, true);
parser.MovePast("|", true); // First parameter is blueprint name
string recipeTemplate = parser.ExtractUntil("bprow", false, true);
if (string.IsNullOrEmpty(recipeTemplate))
{
// Go to the end of the table instead.
recipeTemplate = parser.ExtractUntil("</", false, true);
}
recipeTemplate = recipeTemplate.Replace("{{Item icon|", "").Replace("'''", "").Replace("''", "").Replace("{", "").Replace("}", "").Replace("\r", "").Replace("\n", "").Replace("\\r", "").Replace("\\n", "").Replace(" ", " ").Replace("<small>", " ").Replace("</small>", " ").Replace("=", "").Replace("×", "x").Replace("→", "→").Trim('|', ' ');
string[] templateArgs = recipeTemplate.Split('|');
if (templateArgs.Length < 2)
{
string error = ($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_Oops")}");
output.Append(error).Append(' ').Append(query).Append(": ").AppendLine(url);
}
else
{
output.AppendLine("`Requirements: " + templateArgs[0].Trim() + "`");
output.AppendLine("`Produces: " + templateArgs[1].Trim() + "`");
for (int i = 2; i < templateArgs.Length; i++)
{
if (templateArgs[i].Contains("cost") || i == templateArgs.Length - 1)
{
string costStr = templateArgs[i].Replace("cost", "");
if (costStr.Contains("</"))
{
costStr = (costStr.Substring(0, costStr.IndexOf("</")));
}
output.AppendLine("`Cost: " + costStr.Trim() + " weapon units.`");
break;
}
else
{
output.AppendLine("`" + templateArgs[i].Trim() + "`");
}
}
}
}
}
catch (Exception ex)
{
string error = ($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_Oops")}");
output.AppendLine(error + " " + query + " " + ex.Message);
}
return(Response.CreateArrayFromString(output.ToString()));
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
Response response = new Response
{
Message = "https://www.youtube.com",
ResponseType = ResponseType.Default
};
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string keywords = command.CommandDetail;
if (!string.IsNullOrWhiteSpace(keywords))
{
if (keywords.Length > 150)
{
response.Message = $"{Emojis.CrossSymbol} {languageHandler.GetPhrase(serverSettings.Language, "Error_IncorrectParameter")}: {languageHandler.GetPhrase(serverSettings.Language, "Text")} < 150";
}
else
{
// Already a YouTube URL? Extract the id and prepend it with youtube.com?v=
var match = youtubeRegex.Match(keywords);
if (match.Length > 1)
{
response.Message = $"https://www.youtube.com/watch?v={match.Groups["id"].Value}";
}
else
{
response = waitHandler.CreatePleaseWaitResponse(senderDetail.ServerSettings.Language);
Task.Run(async() =>
{
string asyncRetVal;
string query = $"https://www.googleapis.com/youtube/v3/search?" +
$"part=snippet&maxResults=8" +
$"&q={Uri.EscapeDataString(keywords)}" +
$"&key={Tokens.GoogleAPIKey}";
string json = await GetResponseStringAsync(query);
dynamic data = JsonConvert.DeserializeObject(json);
if (data.items.Count > 0)
{
// Attempt to get the first item that is a video.
int itemIndex = 0;
string videoId;
do
{
videoId = (data.items[itemIndex].id.videoId);
itemIndex++;
}while (itemIndex < data.items.Count && string.IsNullOrWhiteSpace(videoId));
if (string.IsNullOrWhiteSpace(videoId))
{
asyncRetVal = ($"{Emojis.Warning} {languageHandler.GetPhrase(serverSettings.Language, "Error_NoResults")}");
}
else
{
string youTubeURL = ("https://www.youtube.com/watch?v=" + videoId);
switch (youTubeCommandType)
{
case YouTubeCommandType.YouTube:
asyncRetVal = youTubeURL;
break;
case YouTubeCommandType.SaveFrom:
asyncRetVal = ("http://en.savefrom.net/#url=" + youTubeURL);
break;
case YouTubeCommandType.Repeat:
asyncRetVal = ("http://www.youtubeonrepeat.com/watch?v=" + videoId);
break;
default:
asyncRetVal = $"{Emojis.CrossSymbol} {languageHandler.GetPhrase(serverSettings.Language, "Error_Oops")}: {youTubeCommandType}";
break;
}
}
}
else
{
asyncRetVal = $"{Emojis.Warning} {languageHandler.GetPhrase(serverSettings.Language, "Error_NoResults")}";
}
Response asyncResponse = new Response
{
Message = asyncRetVal,
ResponseType = ResponseType.Default
};
await asyncResponder.SendResponseAsync(args, asyncResponse);
waitHandler.PopPleaseWaitMessage();
});
}
}
}
response.Embed = EmbedUtility.ToEmbed(response.Message);
return(new[] { response });
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
// Responds asynchronously.
Task.Run(async() =>
{
var now = DateTime.UtcNow;
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string query = command.CommandDetail;
Player[] matchedPlayers;
Team[] matchedTeams;
string title;
// Call the Slapp
if (string.IsNullOrWhiteSpace(query))
{
matchedPlayers = new Player[0];
matchedTeams = new Team[0];
title = "Nothing to search!";
}
else
{
Task.WaitAll(initialiseTask);
matchedPlayers = splatTagController.MatchPlayer(query);
matchedTeams = splatTagController.MatchTeam(query);
title = $"Found {matchedPlayers.Length} player{((matchedPlayers.Length == 1) ? "" : "s")} and {matchedTeams.Length} team{((matchedTeams.Length == 1) ? "" : "s")}! ";
}
bool hasMatchedPlayers = matchedPlayers.Length != 0;
bool hasMatchedTeams = matchedTeams.Length != 0;
bool showLimitedMessage = matchedPlayers.Length > 9 || matchedTeams.Length > 9;
Color color =
(hasMatchedPlayers && hasMatchedTeams) ? Color.Green :
(hasMatchedPlayers && !hasMatchedTeams) ? Color.Blue :
(!hasMatchedPlayers && hasMatchedTeams) ? Color.Gold :
(!hasMatchedPlayers && !hasMatchedTeams) ? Color.Red :
Color.DarkRed;
var builder = new EmbedBuilder()
.WithColor(color)
.WithAuthor(author => author.WithName(title));
if (hasMatchedPlayers)
{
for (int i = 0; i < matchedPlayers.Length && i < 9; i++)
{
var p = matchedPlayers[i];
var teams = p.Teams.Select(id => splatTagController.GetTeamById(id));
string oldTeams = teams.GetOldTeamsStrings();
var currentTeam = teams.FirstOrDefault();
string info = $"Plays for {currentTeam} {oldTeams}\n _{string.Join(", ", p.Sources)}_";
var playerField = new EmbedFieldBuilder()
.WithIsInline(false)
.WithName(p.Name.Truncate(1000, ""))
.WithValue(info.Truncate(1000, "…_"));
builder.AddField(playerField);
}
}
if (hasMatchedTeams)
{
for (int i = 0; i < matchedTeams.Length && i < 9; i++)
{
var t = matchedTeams[i];
string[] players = t.GetTeamPlayersStrings(splatTagController);
string divPhrase = t.GetBestTeamPlayerDivString(splatTagController);
string info = $"{t.Div}. {divPhrase} Players: {string.Join(matchedTeams.Length == 1 ? ",\n" : ", ", players)}\n _{string.Join(", ", t.Sources)}_";
var teamField = new EmbedFieldBuilder()
.WithIsInline(false)
.WithName($"{t.Tag} {t.Name}".Truncate(1000, ""))
.WithValue(info.Truncate(1000, "…_"));
builder.AddField(teamField);
}
}
builder.WithFooter($"Fetched in {Math.Floor((DateTime.UtcNow - now).TotalMilliseconds)} milliseconds. {(showLimitedMessage ? "Only the first 9 results are shown for players and teams." : "")}",
"https://media.discordapp.net/attachments/471361750986522647/758104388824072253/icon.png");
Response asyncResponse = new Response
{
Embed = builder,
ResponseType = ResponseType.Default,
Message = ""
};
await asyncResponder.SendResponseAsync(args, asyncResponse).ConfigureAwait(false);
});
// Return out the lifecycle with no response.
if (!initialiseTask.IsCompleted)
{
// Also react with a Sloth if the database hasn't loaded yet.
return(new[] { Response.WaitForAsync, Response.CreateFromReact(Emojis.SlothUnicode) });
}
else
{
return(new[] { Response.WaitForAsync });
}
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
CultureInfo cultureInfo = languageHandler.GetCultureInfo(serverSettings.Language);
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string[] commandParams = command.CommandParams;
Discord.Color responseColor = Discord.Color.Green;
string[] typeStrings;
if (command.CommandDetail.Contains('-'))
{
// User wrote e.g. normal-flying
typeStrings = command.CommandDetail.Split('-');
}
else
{
typeStrings = command.CommandArgs.Where(s => !string.IsNullOrWhiteSpace(s)).ToArray();
}
if (typeStrings.Length == 0)
{
// No types specified.
return(Response.CreateArrayFromString("http://bulbapedia.bulbagarden.net/wiki/Type"));
}
List <string> incorrectTypes = new List <string>();
List <string> duplicateTypes = new List <string>();
var foundTypes = new HashSet <PokemonType>();
// TODO - translate.
if (typeStrings.Length == 1 && typeStrings[0].Equals("all", StringComparison.OrdinalIgnoreCase))
{
// Add all types.
foreach (PokemonType t in PokemonTypeHandler.PokemonTypes)
{
if (t != PokemonType.NumberOfTypes)
{
foundTypes.Add(t);
}
}
}
else
{
foreach (string typeStr in typeStrings)
{
bool found = PokemonTypeHandler.GetTypeFromLocalisedName(typeStr, cultureInfo, out PokemonType t);
if (found)
{
bool added = foundTypes.Add(t);
if (!added)
{
duplicateTypes.Add(typeStr);
}
}
else
{
incorrectTypes.Add(typeStr);
}
}
}
bool foundAny = foundTypes.Any();
if (!foundAny)
{
// Check if is actually a Pokémon.
Pokemon pokemon = (KnowledgeBase.GetOrFetchPokémon(command.CommandDetail));
if (pokemon != null)
{
foundTypes.Add(pokemon.PrimaryType);
if (pokemon.SecondaryType != PokemonType.NumberOfTypes)
{
foundTypes.Add(pokemon.SecondaryType);
}
foundAny = true;
// Ignore the typing - it's a Pokémon.
incorrectTypes.Clear();
duplicateTypes.Clear();
}
}
StringBuilder sb = new StringBuilder();
// Incorrect types
if (incorrectTypes.Any())
{
sb.Append($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_IncorrectParameter")}");
sb.Append(": ");
sb.AppendLine(string.Join(" ", incorrectTypes));
}
// Duplicate types
if (duplicateTypes.Any())
{
sb.Append($"{Emojis.ExclamationSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Warning_SameType")}");
sb.Append(": ");
sb.AppendLine(string.Join(" ", duplicateTypes));
}
if (foundAny)
{
sb.AppendLine("```objectivec");
sb.Append("// ");
foreach (PokemonType foundType in foundTypes)
{
string foundTypeName = PokemonTypeHandler.GetLocalisedName(foundType, cultureInfo);
sb.Append(foundTypeName);
sb.Append(" ");
}
sb.AppendLine();
// Attacking
if (foundTypes.Count < 3)
{
sb.AppendLine($"# {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Attacking")}");
foreach (PokemonType foundType in foundTypes)
{
double[] attackingType1 = PokemonTypeHandler.GetAttacking(foundType);
for (int i = 0; i < attackingType1.Length; i++)
{
double eff = attackingType1[i];
if (eff != 1.0)
{
sb.Append(eff.ToString("G", cultureInfo.NumberFormat));
sb.Append($"x {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Against")} ");
sb.Append(PokemonTypeHandler.GetLocalisedName(PokemonTypeHandler.PokemonTypes[i], cultureInfo));
sb.Append($" {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "WhenAttackingWith")} ");
sb.Append(PokemonTypeHandler.GetLocalisedName(foundType, cultureInfo));
sb.AppendLine();
}
}
}
}
sb.AppendLine();
// Defending
sb.AppendLine($"# {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Defending")}");
double[] defending = PokemonTypeHandler.GetDefending(foundTypes.ToArray());
for (int i = 0; i < defending.Length; i++)
{
double eff = defending[i];
if (eff != 1.0)
{
sb.Append(eff.ToString("G", cultureInfo.NumberFormat));
sb.Append($"x {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "DamageTakenFrom")} ");
sb.AppendLine(PokemonTypeHandler.GetLocalisedName(PokemonTypeHandler.PokemonTypes[i], cultureInfo));
}
}
// Add on status immunities.
foreach (PokemonType foundType in foundTypes)
{
string immunity = PokemonTypeHandler.GetTypeStatusImmunityString(foundType, cultureInfo);
if (immunity != string.Empty)
{
sb.AppendLine(immunity);
}
}
sb.Append("```");
}
return(Response.CreateArrayFromString(sb.ToString(), responseColor));
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
StringBuilder output = new StringBuilder();
if ((Constants.IsBotOwner(args.UserId)) || (args.GuildOwnerId == args.UserId))
{
ServerSettings serverSettings = senderDetail.ServerSettings;
IEnumerable <ScheduledMessageData> scheduledData = serverSettings.ScheduledMessages.Where(d => d.channelId == args.ChannelId);
int scheduledDataLength = scheduledData.Count();
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string[] commandParams = command.CommandParams;
switch (commandParams.Length)
{
case 0:
// Should not occur.
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_Oops")}");
break;
case 1:
// Show help.
output.AppendLine(Help);
output.AppendLine(Examples);
output.AppendLine(BuildScheduledMessageInformation(scheduledData, languageHandler.GetCultureInfo(serverSettings.Language), serverSettings.Language));
break;
case 2:
{
// Remove without an id?
if (commandParams[1].Equals("remove", StringComparison.OrdinalIgnoreCase))
{
switch (scheduledDataLength)
{
case 0:
{
// No messages set up
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_NoResults")}");
break;
}
case 1:
{
// Only one, remove that
ScheduledMessageData matchedData = serverSettings.ScheduledMessages.Single(d => d.channelId == args.ChannelId);
AttemptDisable(serverSettings, matchedData, output, senderDetail.ServerSettings.Language);
// And remove
serverSettings.ScheduledMessages.Remove(matchedData);
serverSettingsHandler.WriteServerSettings(serverSettings);
break;
}
default:
{
// More than one, require an id.
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_IncorrectParameter")}: {Constants.BotMention_Nick} {command.CommandLower} remove _id_");
output.AppendLine(BuildScheduledMessageInformation(scheduledData, languageHandler.GetCultureInfo(serverSettings.Language), serverSettings.Language));
break;
}
}
}
else if (commandParams[1].Equals("enable", StringComparison.OrdinalIgnoreCase))
{
switch (scheduledDataLength)
{
case 0:
{
// No messages set up
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_NoResults")}");
break;
}
case 1:
{
// Only one, try to enable that
ScheduledMessageData matchedData = serverSettings.ScheduledMessages.Single(d => d.channelId == args.ChannelId);
AttemptEnable(serverSettings, matchedData, output, serverSettings.Language);
break;
}
default:
{
// More than one, require an id.
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_IncorrectParameter")}: {Constants.BotMention_Nick} {command.CommandLower} enable _id_");
output.AppendLine(BuildScheduledMessageInformation(scheduledData, languageHandler.GetCultureInfo(serverSettings.Language), serverSettings.Language));
break;
}
}
}
else if (commandParams[1].Equals("disable", StringComparison.OrdinalIgnoreCase))
{
switch (scheduledDataLength)
{
case 0:
{
// No messages set up
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_NoResults")}");
break;
}
case 1:
{
// Only one, disable that
ScheduledMessageData matchedData = serverSettings.ScheduledMessages.Single(d => d.channelId == args.ChannelId);
AttemptDisable(serverSettings, matchedData, output, senderDetail.ServerSettings.Language);
break;
}
default:
{
// More than one, require an id.
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_IncorrectParameter")}: {Constants.BotMention_Nick} {command.CommandLower} enable _id_");
output.AppendLine(BuildScheduledMessageInformation(scheduledData, languageHandler.GetCultureInfo(serverSettings.Language), serverSettings.Language));
break;
}
}
}
else if (commandParams[1].Equals("list", StringComparison.OrdinalIgnoreCase))
{
string list = BuildScheduledMessageInformation(scheduledData, languageHandler.GetCultureInfo(serverSettings.Language), serverSettings.Language);
if (list == string.Empty)
{
output.AppendLine("<none>");
}
else
{
output.AppendLine(list);
}
}
else if (commandParams[1].Equals("set", StringComparison.OrdinalIgnoreCase))
{
output.AppendLine($"{Constants.BotMention_Nick} {command.CommandLower} set _id_ <Due|Repeating|Message|Enabled> <_value_>");
output.AppendLine(BuildScheduledMessageInformation(scheduledData, languageHandler.GetCultureInfo(serverSettings.Language), serverSettings.Language));
}
else if (commandParams[1].Equals("new", StringComparison.OrdinalIgnoreCase))
{
ushort id = 1;
var takenIds = serverSettings.ScheduledMessages.Select(d => d.id).ToArray();
while (takenIds.Contains(id))
{
++id;
}
serverSettings.ScheduledMessages.Insert(id - 1, new ScheduledMessageData(args.ChannelId, id));
output.AppendLine($"{Constants.BotMention_Nick} {command.CommandLower} set **{id}** <Due|Repeating|Message|Enabled> <_value_>");
output.AppendLine(BuildScheduledMessageInformation(scheduledData, languageHandler.GetCultureInfo(serverSettings.Language), serverSettings.Language));
}
break;
}
case 3:
{
bool idParsed = ushort.TryParse(commandParams[2], out ushort id);
if (!idParsed)
{
// Id not in range
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_IncorrectParameter")}: {id}");
output.AppendLine(BuildScheduledMessageInformation(scheduledData, languageHandler.GetCultureInfo(serverSettings.Language), serverSettings.Language));
}
else
{
var matchedData = serverSettings.ScheduledMessages.Find(m => m.id == id);
if (matchedData != default(ScheduledMessageData))
{
if (commandParams[1].Equals("set", StringComparison.OrdinalIgnoreCase))
{
output.AppendLine($"{Constants.BotMention_Nick} {command.CommandLower} set _id_ <Due|Repeating|Message|Enabled> <value>");
output.AppendLine(BuildScheduledMessageInformation(scheduledData, languageHandler.GetCultureInfo(serverSettings.Language), serverSettings.Language));
}
else if (commandParams[1].Equals("enable", StringComparison.OrdinalIgnoreCase))
{
AttemptEnable(serverSettings, matchedData, output, serverSettings.Language);
}
else if (commandParams[1].Equals("disable", StringComparison.OrdinalIgnoreCase))
{
AttemptDisable(serverSettings, matchedData, output, serverSettings.Language);
}
else
{
// Remove with an id?
if (commandParams[1].Equals("remove", StringComparison.OrdinalIgnoreCase))
{
if (!scheduledData.Any())
{
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_NoResults")}");
}
else
{
if (id > 0 && id <= scheduledDataLength)
{
AttemptDisable(serverSettings, matchedData, output, senderDetail.ServerSettings.Language);
// And remove
serverSettings.ScheduledMessages.Remove(matchedData);
serverSettingsHandler.WriteServerSettings(serverSettings);
output.AppendLine(BuildScheduledMessageInformation(scheduledData, languageHandler.GetCultureInfo(serverSettings.Language), serverSettings.Language));
}
}
}
}
}
else
{
// Id not found
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_IncorrectParameter")}: {id}");
output.AppendLine(BuildScheduledMessageInformation(scheduledData, languageHandler.GetCultureInfo(serverSettings.Language), serverSettings.Language));
}
}
break;
}
// 4 or more
default:
{
bool idParsed = uint.TryParse(commandParams[2], out uint id);
if (!idParsed)
{
// Id not in range
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_IncorrectParameter")}: {id}");
output.AppendLine(BuildScheduledMessageInformation(scheduledData, languageHandler.GetCultureInfo(serverSettings.Language), serverSettings.Language));
}
else
{
var matchedData = serverSettings.ScheduledMessages.Find(m => m.id == id);
if (matchedData != default(ScheduledMessageData))
{
if (commandParams[1].Equals("set", StringComparison.OrdinalIgnoreCase))
{
// Due|Repeating|Message|Enabled
if (commandParams[3].Equals("Due", StringComparison.OrdinalIgnoreCase))
{
string dueStr = string.Join(" ", commandParams.Skip(4));
if (string.IsNullOrWhiteSpace(dueStr))
{
output.AppendLine($"{Emojis.InfoSymbol} Due is the next time to send the message e.g. 5:30pm, 00:00");
}
else
{
bool success = DateTime.TryParse(dueStr, languageHandler.GetCultureInfo(serverSettings.Language), DateTimeStyles.AssumeUniversal, out matchedData.nextDue);
if (success)
{
matchedData.nextDue = matchedData.nextDue.ToUniversalTime();
while (matchedData.nextDue < DateTime.UtcNow)
{
matchedData.nextDue = matchedData.nextDue.AddDays(1);
}
string localisedToGo = languageHandler.GetLocalisedTimeSpan(serverSettings.Language, matchedData.nextDue - DateTime.UtcNow);
output.AppendLine($"{Emojis.TimerSymbol} {matchedData.nextDue.ToString("t")} UTC ({localisedToGo})");
serverSettingsHandler.WriteServerSettings(serverSettings);
}
else
{
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_IncorrectParameter")}: {dueStr}");
}
}
}
else if (commandParams[3].Equals("Repeating", StringComparison.OrdinalIgnoreCase))
{
string repeatingStr = string.Join(" ", commandParams.Skip(4));
if (string.IsNullOrWhiteSpace(repeatingStr))
{
output.AppendLine($"{Emojis.InfoSymbol} Repeating is the period to wait between each message, or 0 to not repeat. In form _days_ or _days_._hours_:_minutes_:_seconds_ or _hours_:_minutes_:_seconds_");
}
else
{
bool success = TimeSpan.TryParse(repeatingStr, languageHandler.GetCultureInfo(senderDetail.ServerSettings.Language), out matchedData.repetitionTimeSpan);
if (success)
{
TimeSpan ts = matchedData.repetitionTimeSpan;
string localisedTs = languageHandler.GetLocalisedTimeSpan(serverSettings.Language, ts);
output.AppendLine($"{Emojis.RepeatSymbol} {localisedTs}");
serverSettingsHandler.WriteServerSettings(serverSettings);
}
else
{
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_IncorrectParameter")}: {repeatingStr}");
}
}
}
else if (commandParams[3].Equals("Message", StringComparison.OrdinalIgnoreCase))
{
string messageStr = string.Join(" ", commandParams.Skip(4));
if (string.IsNullOrWhiteSpace(messageStr))
{
output.AppendLine($"{Emojis.InfoSymbol} Message is the message to write.");
}
else
{
matchedData.message = messageStr;
output.AppendLine($"{Emojis.MessageUnicode} {messageStr}");
serverSettingsHandler.WriteServerSettings(serverSettings);
}
}
else if (commandParams[3].Equals("Enabled", StringComparison.OrdinalIgnoreCase))
{
string enabledStr = string.Join(" ", commandParams.Skip(4));
if (string.IsNullOrWhiteSpace(enabledStr))
{
output.AppendLine($"{Emojis.InfoSymbol} Enabled is if the message should be enabled (true/false). Long hand for the enable/disable command.");
}
else
{
if (enabledStr.Equals("true", StringComparison.OrdinalIgnoreCase) || enabledStr.Equals("yes", StringComparison.OrdinalIgnoreCase) || enabledStr.Equals("y", StringComparison.OrdinalIgnoreCase))
{
AttemptEnable(serverSettings, matchedData, output, senderDetail.ServerSettings.Language);
serverSettingsHandler.WriteServerSettings(serverSettings);
}
else if (enabledStr.Equals("false", StringComparison.OrdinalIgnoreCase) || enabledStr.Equals("no", StringComparison.OrdinalIgnoreCase) || enabledStr.Equals("n", StringComparison.OrdinalIgnoreCase))
{
AttemptDisable(serverSettings, matchedData, output, senderDetail.ServerSettings.Language);
serverSettingsHandler.WriteServerSettings(serverSettings);
}
else
{
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_IncorrectParameter")}: {enabledStr}");
}
}
}
else
{
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_IncorrectParameter")}: {commandParams[3]}");
output.AppendLine($"{Constants.BotMention_Nick} {command.CommandLower} set _id_ <Due|Repeating|Message|Enabled> [value]");
}
}
}
else
{
// Id not found
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_IncorrectParameter")}: {id}");
output.AppendLine(BuildScheduledMessageInformation(scheduledData, languageHandler.GetCultureInfo(serverSettings.Language), serverSettings.Language));
}
}
break;
}
}
}
else
{
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_ServerOwnerOnly")}");
}
return(new[] { new Response
{
Message = output.ToString(),
ResponseType = ResponseType.Default
} });
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string[] commandParams = command.CommandParams;
Discord.Color responseColor = Discord.Color.Green;
object ans;
StringBuilder output = new StringBuilder();
string commandDetail = command.CommandDetail;
try
{
if (commandDetail.Contains('!'))
{
output.AppendLine("*! is ambiguous, use ~ for 'bitwise-not'. Factorial is not yet supported. Assuming conditional-not.*");
}
if (commandDetail.Contains('^'))
{
output.AppendLine("*Assumed ^ means XOR. For Power, use Pow(x,y).*");
}
if (commandDetail.Contains('%'))
{
output.AppendLine("*Assumed % means modulo. For percentages, simply divide by 100.*");
}
if (commandDetail.Count(c => c == '=') == 1)
{
output.AppendLine($"*Assumed = means is equal. For an equation solver, use the `{senderDetail.ServerSettings.CommandSymbol}wolframalpha` (`{senderDetail.ServerSettings.CommandSymbol}wa`) command.*");
}
// Tidy up some common operator symbols.
commandDetail = commandDetail
.Replace("fix", "floor") // before the x replacement
.Replace("x", "*")
.Replace("modulo", "mod")
.Replace("mod", "%")
.Replace("¬", "~")
.Replace("cosine", "cos")
.Replace("sine", "sin")
.Replace("tangent", "tan")
.Replace("sqr ", "sqrt ")
.Replace("root", "sqrt")
.Replace("√", "sqrt")
.Replace("atn", "atan")
.Replace("π", "[pi]")
.Replace("∞", "[infinity]")
.Replace("pi ", "[pi] ")
.Replace("infinity", "[infinity]")
.Replace("inf", "[infinity]");
// Use ; to split statements. : can be used for more powerful functionality
// such as [Convert]::ToString(1234, 16)
foreach (string split in commandDetail.Split(';'))
{
Expression e = new Expression(split, EvaluateOptions.NoCache | EvaluateOptions.IgnoreCase);
e.Parameters["pi"] = Math.PI;
e.Parameters["e"] = Math.E;
e.Parameters["infinity"] = double.MaxValue;
ans = e.Evaluate();
if (ans == null)
{
output.AppendLine("I don't understand your input (undefined). Please check constants are enclosed by parentheses.");
}
else
{
if (e.HasErrors())
{
output.AppendLine(e.Error);
}
else
{
output.AppendLine(split + " == " + ans.ToString());
}
}
}
}
catch (EvaluationException eEx)
{
responseColor = Discord.Color.Red;
output.AppendLine("I can't evaluate your input: " + eEx.Message + ".");
}
catch (DivideByZeroException)
{
output.AppendLine("NaN.");
}
catch (OverflowException)
{
responseColor = Discord.Color.Red;
output.AppendLine("Overflow.");
}
Response response = new Response
{
Embed = Utility.EmbedUtility.ToEmbed(output.ToString(), responseColor),
Message = output.ToString(),
ResponseType = ResponseType.Default
};
return(new[] { response });
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
// Responds asynchronously.
Task.Run(async() =>
{
CommandMessageHelper command = new CommandMessageHelper(senderDetail.ServerSettings.CommandSymbol, args.Message);
string manualUrl = "http://minecraft.gamepedia.com/index.php?search=" + command.EscapedCommandDetail + "&title=Special%3ASearch&go=Go";
StringBuilder output = new StringBuilder(manualUrl + " \n");
string[] craftingTemplateParams = new string[] { "\n", "|" };
string query = command.EscapedCommandDetail;
string json = "";
try
{
bool redirectResolved = true;
// Resolve redirects
do
{
json = await WebHelper.GetTextAsync($"http://minecraft.gamepedia.com/api.php?format=json&action=query&titles={query}&prop=revisions&rvprop=content&callback=?");
if (json.Contains(RedirectString))
{
// Resolve redirect
TextParser parser = new TextParser(json);
parser.MovePast(RedirectString, true);
parser.MovePast("[[", true);
string article = parser.ExtractUntil("]]", false, true);
string newQuery = Uri.EscapeDataString(article);
if (query == newQuery)
{
output.AppendLine(Emojis.ExclamationSymbol + " infinite recursion error on: " + query);
redirectResolved = false;
break;
}
else
{
query = newQuery;
}
}
}while (json.Contains(RedirectString));
if (redirectResolved)
{
string url = "http://minecraft.gamepedia.com/" + query;
// Get the recipe.
if (!json.ContainsIgnore(CraftingString, StringComparison.OrdinalIgnoreCase, " ", "\n", "\r"))
{
string error = Emojis.InfoSymbol + " " + languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_UnknownRecipe");
output.AppendLine(error + " " + command.CommandDetail + ": " + url);
}
else
{
// We're in business.
TextParser parser = new TextParser(json);
parser.MovePast(CraftingString, true);
string recipeTemplate = parser.ExtractUntil("}}", false, true).Replace("|head=0", "").Replace("|head=1", "").Replace("|showdescription=0", "").Replace("|showdescription=1", "").Replace("|showname=0", "").Replace("|showname=1", "");
parser = new TextParser(recipeTemplate);
parser.MovePast("|", true); // First parameter is template name
string[,] recipe = new string[3, 3];
// Initialise all elements with an empty string.
for (int x = 0; x < 3; x++)
{
for (int y = 0; y < 3; y++)
{
recipe[x, y] = "";
}
}
if (recipeTemplate.Contains("A2") || recipeTemplate.Contains("B2") || recipeTemplate.Contains("C2"))
{
// Method 1, cells specified
string a1Cell = parser.ExtractBetween("A1", craftingTemplateParams, true);
recipe[0, 0] = TidyRecipeParameter(a1Cell);
string b1Cell = parser.ExtractBetween("B1", craftingTemplateParams, true);
recipe[1, 0] = TidyRecipeParameter(b1Cell);
string c1Cell = parser.ExtractBetween("C1", craftingTemplateParams, true);
recipe[2, 0] = TidyRecipeParameter(c1Cell);
string a2Cell = parser.ExtractBetween("A2", craftingTemplateParams, true);
recipe[0, 1] = TidyRecipeParameter(a2Cell);
string b2Cell = parser.ExtractBetween("B2", craftingTemplateParams, true);
recipe[1, 1] = TidyRecipeParameter(b2Cell);
string c2Cell = parser.ExtractBetween("C2", craftingTemplateParams, true);
recipe[2, 1] = TidyRecipeParameter(c2Cell);
string a3Cell = parser.ExtractBetween("A3", craftingTemplateParams, true);
recipe[0, 2] = TidyRecipeParameter(a3Cell);
string b3Cell = parser.ExtractBetween("B3", craftingTemplateParams, true);
recipe[1, 2] = TidyRecipeParameter(b3Cell);
string c3Cell = parser.ExtractBetween("C3", craftingTemplateParams, true);
recipe[2, 2] = TidyRecipeParameter(c3Cell);
}
else
{
// Method 2, all fields present -OR- clockwise layout.
List <string> items = new List <string>();
for (int i = 0; i < 9; i++)
{
string candidateItem = TidyRecipeParameter(parser.ExtractUntil(craftingTemplateParams, false, true));
if (candidateItem.Contains("output", StringComparison.OrdinalIgnoreCase))
{
break;
}
else
{
items.Add(candidateItem);
parser.MovePast("|");
}
}
// If we have less than 4, then it's constructed in a clockwise fashion.
switch (items.Count)
{
case 0:
break;
case 1:
recipe[0, 1] = items[0];
break;
case 2:
recipe[0, 1] = items[0];
recipe[1, 1] = items[1];
break;
case 3:
recipe[0, 1] = items[0];
recipe[1, 1] = items[1];
recipe[1, 2] = items[2];
break;
case 4:
recipe[0, 1] = items[0];
recipe[1, 1] = items[1];
recipe[1, 2] = items[2];
recipe[0, 2] = items[3];
break;
default:
{
recipe[0, 1] = items[0];
recipe[1, 1] = items[1];
recipe[1, 2] = items[2];
recipe[0, 2] = items[3];
break;
}
case 9:
// Otherwise, all parameters are specified and just go from top left to bottom right.
for (int x = 0; x < 3; x++)
{
for (int y = 0; y < 3; y++)
{
recipe[x, y] = items[(x * 3) + y];
}
}
break;
}
}
parser.MovePast(OutputNameString, true);
string outputName = TidyRecipeParameter(parser.ExtractUntil(craftingTemplateParams, false, true));
if (string.IsNullOrWhiteSpace(outputName))
{
string error = Emojis.ExclamationSymbol + " " + languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_UnknownRecipe");
output.AppendLine($"{error}{command.CommandDetail}: " + url);
}
else
{
const int pad = 14;
output.AppendLine($"```"); // Mono-space engage!
output.AppendLine($"|--------------|--------------|--------------|");
output.AppendLine($"|{recipe[0, 0].CentreString(pad)}|{recipe[1, 0].CentreString(pad)}|{recipe[2, 0].CentreString(pad)}|");
output.AppendLine($"|--------------|--------------|--------------|");
output.AppendLine($"|{recipe[0, 1].CentreString(pad)}|{recipe[1, 1].CentreString(pad)}|{recipe[2, 1].CentreString(pad)}|");
output.AppendLine($"|--------------|--------------|--------------|");
output.AppendLine($"|{recipe[0, 2].CentreString(pad)}|{recipe[1, 2].CentreString(pad)}|{recipe[2, 2].CentreString(pad)}|");
output.AppendLine($"|--------------|--------------|--------------|");
output.AppendLine($"```");
output.AppendLine($"{outputName}");
}
}
}
}
catch (Exception ex)
{
string error = Emojis.CrossSymbol + " " + languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_Oops");
output.AppendLine(error + " " + command.CommandDetail);
errorLogger.LogDebug("Query: " + query, true);
errorLogger.LogDebug("JSON: " + json, true);
errorLogger.LogDebug(ex.ToString(), true);
}
Response asyncResponse = new Response
{
ResponseType = ResponseType.Default,
Embed = EmbedUtility.ToEmbed(output.ToString(), null),
Message = output.ToString()
};
await asyncResponder.SendResponseAsync(args, asyncResponse);
});
// Return out the lifecycle with no response.
return(new[] { Response.WaitForAsync });
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
CultureInfo cultureInfo = languageHandler.GetCultureInfo(serverSettings.Language);
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
Discord.Color responseColor = Discord.Color.Green;
// First, check the cache if we already have this pokémon.
string query = command.CommandDetail;
if (args.URLs.Length > 0)
{
var response = new[] { waitHandler.CreatePleaseWaitResponse(senderDetail.ServerSettings.Language) };
Task.Run(async() =>
{
Response asyncResponse = await CorrelatePokemonAsync(senderDetail.ServerSettings.Language, args);
if (asyncResponse == null)
{
string err = ($"{Emojis.NoEntry} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_NoImageMessages")}");
asyncResponse = new Response
{
Embed = EmbedUtility.ToEmbed(err),
Message = err,
ResponseType = ResponseType.Default
};
}
await asyncResponder.SendResponseAsync(args, asyncResponse);
waitHandler.PopPleaseWaitMessage();
});
return(response);
}
query = query.Replace("(Pokemon)", "").Replace("(Pokémon)", "").Trim();
query = query.Replace("(move)", "").Trim();
StringBuilder output = new StringBuilder();
Pokemon pokemon = KnowledgeBase.GetPokémon(query);
string imageUrl = null;
bool isCached = (pokemon != null);
try
{
// For now, assume that it is a Pokémon.
string url = "https://bulbapedia.bulbagarden.net/wiki/" + query.Capitalize() + "_(Pokémon)";
string urlRaw = url + "?action=raw";
if (!isCached)
{
// Assume correct URL
pokemon = Pokemon.ParsePage(urlRaw);
}
if (pokemon != null)
{
string p = pokemon.Name + "_(Pokémon)";
dynamic imageJson = null;
output
.Append("https://bulbapedia.bulbagarden.net/wiki/")
.Append(p)
.AppendLine("#") // # is for mobile where () is not correctly parsed in the URL parser
.AppendLine(MakeAPokemonString(pokemon, cultureInfo, serverSettings.Language));
try
{
cancellationTokenSource.CancelAfter(300000);
Task.Run(async() =>
{
imageJson = await JSONHelper.GetJsonAsync(Uri.EscapeUriString("https://bulbapedia.bulbagarden.net/w/api.php?action=query&format=json&prop=pageimages&titles=" + p)).ConfigureAwait(false);
}, cancellationTokenSource.Token).Wait();
JToken token = imageJson["query"]["pages"];
token = token.First.First;
imageUrl = token["thumbnail"]["source"]?.ToString();
}
catch (TaskCanceledException tcex)
{
errorLogger.LogDebug("Did not query Bulbapedia in time to retrieve the Pokemon image.", true);
errorLogger.LogException(tcex, ErrorSeverity.Warning);
}
catch (Exception ex)
{
errorLogger.LogDebug($"Exception occurred retrieving the Pokemon image for {pokemon?.Name}.\n" +
$"imageUrl: {imageUrl}\n" +
$"imageJson: {imageJson}", true);
errorLogger.LogException(ex, ErrorSeverity.Error);
}
}
else
{
output.AppendLine($"{Emojis.ExclamationSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_PokemonNotFound")}: {urlRaw}");
}
}
catch (WebException)
{
output.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_PokemonNotFound")}: {query}");
}
catch (Exception ex)
{
output.AppendLine($"{languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_Oops")}: {ex.Message}");
}
return(Response.CreateArrayFromString(output.ToString(), responseColor, pokemon.Name, imageUrl));
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
StringBuilder sb = new StringBuilder();
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string commandDetail = command.CommandDetail;
Discord.Color?embedColour = null;
if (string.IsNullOrEmpty(commandDetail))
{
sb.AppendLine(Help);
}
else
{
// Remove decorators
commandDetail = commandDetail.Replace("0x", "").Replace("0b", "").Replace("#", "");
// Replace commas with spaces
commandDetail = commandDetail.Replace(",", " ").Trim();
// Special case hex to decimal in cases of 6 or 8 characters.
bool is6Chars = commandDetail.Length == 6;
bool is8Chars = commandDetail.Length == 8;
if (fromBase == 16 && (is6Chars || is8Chars))
{
// Try and convert the source hex number into a colour.
if (uint.TryParse(commandDetail, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out uint argb))
{
// Remove alpha channel (N.B. this usually makes it transparent as a = 0, but Discord fixes this to fully opaque)
argb &= 0x00FFFFFF;
embedColour = new Discord.Color(argb);
}
commandDetail += " ";
commandDetail += commandDetail.Substring(0, 2);
commandDetail += " ";
commandDetail += commandDetail.Substring(2, 2);
commandDetail += " ";
commandDetail += commandDetail.Substring(4, 2);
if (is8Chars)
{
commandDetail += " ";
commandDetail += commandDetail.Substring(6, 2);
}
}
string[] commandParams = commandDetail.Split(' ').Where(s => !string.IsNullOrWhiteSpace(s)).ToArray();
if (fromBase == 10)
{
// Try and convert the source decimal number(s) into a colour.
if (commandParams.Length == 1)
{
if (uint.TryParse(commandParams[0], out uint argb))
{
// Remove alpha channel (N.B. this usually makes it transparent as a = 0, but Discord fixes this to fully opaque)
argb &= 0x00FFFFFF;
embedColour = new Discord.Color(argb);
}
}
else if (commandParams.Length == 3 || commandParams.Length == 4)
{
// Using -n here as alpha could be included at the front.
bool canParseColour = (byte.TryParse(commandParams[commandParams.Length - 3], out byte r));
canParseColour &= (byte.TryParse(commandParams[commandParams.Length - 2], out byte g));
canParseColour &= (byte.TryParse(commandParams[commandParams.Length - 1], out byte b));
if (canParseColour)
{
embedColour = new Discord.Color(r, g, b);
}
}
}
foreach (string col in commandParams)
{
try
{
switch (fromBase)
{
case 2:
case 8:
case 10:
case 16:
{
long part = Convert.ToInt64(col, fromBase);
byte[] parts = BitConverter.GetBytes(part);
if (toBase == 64)
{
sb.Append(Convert.ToBase64String(parts) + " ");
}
else if (toBase == 16)
{
sb.Append(part.ToString("X2") + " ");
}
else
{
sb.Append(Convert.ToString(part, toBase) + " ");
}
break;
}
case 64:
{
byte[] parts = Convert.FromBase64String(col);
long part = BitConverter.ToInt64(parts, 0);
if (toBase == 64)
{
sb.Append(Convert.ToBase64String(parts) + " ");
}
else if (toBase == 16)
{
sb.Append(part.ToString("X2") + " ");
}
else
{
sb.Append(Convert.ToString(part, toBase) + " ");
}
break;
}
}
}
catch (FormatException)
{
sb.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(serverSettings.Language, "Error_IncorrectParameter")}: {col}.");
}
catch (Exception ex)
{
sb.AppendLine($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(serverSettings.Language, "Error_Oops")}: {col} {ex.Message}");
}
}
// If multiple things to translate, also provide the answer without spaces.
if (command.CommandParams.Length > 2)
{
string outputWithoutSpace = sb.ToString().Replace(" ", "");
sb.AppendLine();
switch (toBase)
{
case 2: sb.Append("0b "); break;
case 8: sb.Append("0o "); break;
case 16: sb.Append("0x "); break;
}
sb.AppendLine(outputWithoutSpace);
}
}
string output = sb.ToString();
Response response = new Response
{
Embed = EmbedUtility.ToEmbed(output, embedColour),
Message = output,
ResponseType = ResponseType.Default
};
return(new[] { response });
}
