public static async Task OnMessageCreated(MessageCreateEventArgs args)
{
if (DefaultHandlerFilter.IsFluff(args.Message))
{
return;
}
if (!args.Author.IsWhitelisted(args.Client, args.Message.Channel.Guild))
{
return;
}
if (!NeedToSilence(args.Message))
{
return;
}
var botMember = args.Guild?.CurrentMember ?? args.Client.GetMember(args.Client.CurrentUser);
if (!args.Channel.PermissionsFor(botMember).HasPermission(Permissions.ReadMessageHistory))
{
await args.Message.ReactWithAsync(args.Client, DiscordEmoji.FromUnicode("🙅"), @"No can do, boss ¯\\_(ツ)\_/¯").ConfigureAwait(false);
return;
}
await args.Message.ReactWithAsync(args.Client, DiscordEmoji.FromUnicode("😟"), "Okay (._.)").ConfigureAwait(false);
var lastBotMessages = await args.Channel.GetMessagesBeforeAsync(args.Message.Id, 20, DateTime.UtcNow.AddMinutes(-5)).ConfigureAwait(false);
if (lastBotMessages.OrderByDescending(m => m.CreationTimestamp).FirstOrDefault(m => m.Author.IsCurrent) is DiscordMessage msg)
{
await msg.DeleteAsync("asked to shut up").ConfigureAwait(false);
}
}
public static async Task OnMessageCreated(DiscordClient _, MessageCreateEventArgs args)
{
if (DefaultHandlerFilter.IsFluff(args.Message))
{
return;
}
/*
* (╯°□°）╯︵ ┻━┻
* (ノ ゜Д゜)ノ ︵ ┻━┻
* (ノಠ益ಠ)ノ彡┻━┻
* (ﾉಥ益ಥ）ﾉ ┻━┻
* (ﾉಥДಥ)ﾉ︵┻━┻･/
* (ノ^_^)ノ┻━┻
* (/¯◡ ‿ ◡)/¯ ~ ┻━┻
*
* this might look the same, but only because of the font choice
*
* ┻━┻
* ┻━┻
*/
try
{
var content = args.Message.Content;
if (content.Contains("🎲") && Regex.IsMatch(content, @"(🎲|\s)+"))
{
var count = 1;
var idx = content.IndexOf("🎲");
while (idx < content.Length && (idx = content.IndexOf("🎲", idx + 1)) > 0)
{
count++;
}
await Misc.RollImpl(args.Message, $"{count}d6").ConfigureAwait(false);
return;
}
if (content.Trim() == "🥠")
{
await Fortune.ShowFortune(args.Message, args.Author).ConfigureAwait(false);
return;
}
if (!(content.Contains("┻━┻") ||
content.Contains("┻━┻")))
{
return;
}
var tableIdx = content.IndexOf("┻━┻", StringComparison.Ordinal);
if (tableIdx < 0)
{
tableIdx = content.IndexOf("┻━┻", StringComparison.Ordinal);
}
var faceIdx = content[..tableIdx].LastIndexOfAny(OpenParen);
public static async Task OnMessageCreated(DiscordClient _, MessageCreateEventArgs args)
{
if (DefaultHandlerFilter.IsFluff(args?.Message))
{
return;
}
#if !DEBUG
if (!"help".Equals(args?.Channel?.Name, StringComparison.InvariantCultureIgnoreCase))
{
return;
}
if (DateTime.UtcNow - lastMention < ThrottlingThreshold)
{
return;
}
#endif
var match = UploadLogMention.Match(args.Message.Content);
if (!match.Success || string.IsNullOrEmpty(match.Groups["help"].Value))
{
return;
}
if (!await TheDoor.WaitAsync(0).ConfigureAwait(false))
{
return;
}
try
{
var explanation = await GetExplanationAsync(string.IsNullOrEmpty(match.Groups["vulkan"].Value)? "log" : "vulkan-1").ConfigureAwait(false);
var lastBotMessages = await args.Channel.GetMessagesBeforeCachedAsync(args.Message.Id, 10).ConfigureAwait(false);
foreach (var msg in lastBotMessages)
{
if (BotReactionsHandler.NeedToSilence(msg).needToChill ||
(msg.Author.IsCurrent && msg.Content == explanation.Text))
{
return;
}
}
await args.Channel.SendMessageAsync(explanation.Text, explanation.Attachment, explanation.AttachmentFilename).ConfigureAwait(false);
lastMention = DateTime.UtcNow;
}
finally
{
TheDoor.Release();
}
}
public static async Task OnMessageCreated(DiscordClient _, MessageCreateEventArgs args)
{
if (DefaultHandlerFilter.IsFluff(args.Message))
{
return;
}
if (!"help".Equals(args.Channel.Name, StringComparison.InvariantCultureIgnoreCase))
{
return;
}
if ((args.Message.Author as DiscordMember)?.Roles.Any() ?? false)
{
return;
}
if (LogLine.IsMatch(args.Message.Content))
{
var brokenDump = false;
string msg = "";
if (args.Message.Content.Contains("LDR:"))
{
brokenDump = true;
if (args.Message.Content.Contains("fs::file is null"))
{
msg = $"{args.Message.Author.Mention} this error usually indicates a missing `.rap` license file.\n";
}
else if (args.Message.Content.Contains("Invalid or unsupported file format"))
{
msg = $"{args.Message.Author.Mention} this error usually indicates an encrypted or corrupted game dump.\n";
}
else
{
brokenDump = false;
}
}
var logUploadExplain = await PostLogHelpHandler.GetExplanationAsync("log").ConfigureAwait(false);
if (brokenDump)
{
msg += "Please follow the quickstart guide to get a proper dump of a digital title.\n" +
"Also please upload the full RPCS3 log instead of pasting only a section which may be completely irrelevant.\n" +
logUploadExplain.Text;
}
else
{
msg = $"{args.Message.Author.Mention} please upload the full RPCS3 log instead of pasting only a section which may be completely irrelevant." +
logUploadExplain.Text;
}
await args.Channel.SendMessageAsync(msg, logUploadExplain.Attachment, logUploadExplain.AttachmentFilename).ConfigureAwait(false);
}
}
public static async Task OnMessageCreated(MessageCreateEventArgs args)
{
if (DefaultHandlerFilter.IsFluff(args.Message))
{
return;
}
if (args.Channel.IsPrivate)
{
return;
}
if (args.Author.IsCurrent)
{
return;
}
if (args.Author.Id == 197163728867688448ul)
{
return;
}
if (!MessageQueue.TryGetValue(args.Channel.Id, out var queue))
{
MessageQueue[args.Channel.Id] = queue = new ConcurrentQueue <DiscordMessage>();
}
queue.Enqueue(args.Message);
while (queue.Count > 4)
{
queue.TryDequeue(out _);
}
var content = args.Message.Content;
if (string.IsNullOrEmpty(content))
{
return;
}
if (Throttling.TryGetValue(args.Channel.Id, out object mark) && mark != null)
{
return;
}
var similarList = queue.Where(msg => content.Equals(msg.Content, StringComparison.InvariantCultureIgnoreCase)).ToList();
if (similarList.Count > 2 && similarList.Select(msg => msg.Author.Id).Distinct().Count() > new Random().Next(2, 5))
{
Throttling.Set(args.Channel.Id, similarList, ThrottleDuration);
var botMsg = await args.Channel.SendMessageAsync(content.ToLowerInvariant()).ConfigureAwait(false);
similarList.Add(botMsg);
}
}
public static async Task OnMessageCreated(DiscordClient c, MessageCreateEventArgs args)
{
if (DefaultHandlerFilter.IsFluff(args.Message))
{
return;
}
var lastBotMessages = await args.Channel.GetMessagesBeforeAsync(args.Message.Id, 20, DateTime.UtcNow.AddSeconds(-30)).ConfigureAwait(false);
foreach (var msg in lastBotMessages)
{
if (BotReactionsHandler.NeedToSilence(msg).needToChill)
{
return;
}
}
lastBotMessages = await args.Channel.GetMessagesBeforeCachedAsync(args.Message.Id, Config.ProductCodeLookupHistoryThrottle).ConfigureAwait(false);
StringBuilder previousRepliesBuilder = null;
foreach (var msg in lastBotMessages)
{
if (msg.Author.IsCurrent)
{
previousRepliesBuilder ??= new StringBuilder();
previousRepliesBuilder.AppendLine(msg.Content);
var embeds = msg.Embeds;
if (embeds?.Count > 0)
{
foreach (var embed in embeds)
{
previousRepliesBuilder.AppendLine(embed.Title).AppendLine(embed.Description);
}
}
}
}
var previousReplies = previousRepliesBuilder?.ToString() ?? "";
var codesToLookup = GetProductIds(args.Message.Content)
.Where(c => !previousReplies.Contains(c, StringComparison.InvariantCultureIgnoreCase))
.Take(args.Channel.IsPrivate ? 50 : 5)
.ToList();
if (codesToLookup.Count == 0)
{
return;
}
await LookupAndPostProductCodeEmbedAsync(c, args.Message, codesToLookup).ConfigureAwait(false);
}
private static async Task <bool> IsClean(DiscordClient client, DiscordMessage message)
{
if (DefaultHandlerFilter.IsFluff(message))
{
return(true);
}
if (message.Author.IsWhitelisted(client, message.Channel.Guild))
{
return(true);
}
string trigger = null;
var severity = ReportSeverity.Low;
try
{
trigger = await PiracyStringProvider.FindTriggerAsync(message.Content);
if (trigger == null)
{
return(true);
}
await message.Channel.DeleteMessageAsync(message, $"Mention of piracy trigger '{trigger}'").ConfigureAwait(false);
}
catch (Exception e)
{
Config.Log.Warn(e, $"Couldn't delete message in {message.Channel.Name}");
severity = ReportSeverity.High;
}
try
{
var rules = await client.GetChannelAsync(Config.BotRulesChannelId).ConfigureAwait(false);
await Task.WhenAll(
message.Channel.SendMessageAsync($"{message.Author.Mention} Please follow the {rules.Mention} and do not discuss piracy on this server. Repeated offence may result in a ban."),
client.ReportAsync("Mention of piracy", message, trigger, message.Content, severity),
Warnings.AddAsync(client, message, message.Author.Id, message.Author.Username, client.CurrentUser, "Mention of piracy", message.Content.Sanitize())
).ConfigureAwait(false);
}
catch (Exception e)
{
Config.Log.Warn(e, $"Couldn't finish piracy trigger actions for a message in {message.Channel.Name}");
}
return(false);
}
public static async Task OnMessageCreated(MessageCreateEventArgs args)
{
if (DefaultHandlerFilter.IsFluff(args.Message))
{
return;
}
var matches = BuildLinks.Matches(args.Message.Content);
if (matches.Count == 0)
{
return;
}
await args.Message.ReactWithAsync(Config.Reactions.PleaseWait).ConfigureAwait(false);
try
{
var lookedUp = 0;
foreach (Match match in matches)
{
if (lookedUp > 0 && global::GithubClient.Client.RateLimitRemaining < Math.Max(20, global::GithubClient.Client.RateLimit / 2))
{
await args.Message.RespondAsync("Further lookups are rate limited by github API").ConfigureAwait(false);
break;
}
if (lookedUp > 4)
{
break;
}
int?pr = null;
if (match.Groups["build_id"].Value is string buildId && !string.IsNullOrEmpty(buildId))
{
var buildInfo = await AppveyorClient.GetBuildInfoAsync("https://ci.appveyor.com/api/projects/rpcs3/rpcs3/build/" + buildId, Config.Cts.Token).ConfigureAwait(false);
pr = buildInfo?.Build?.PullRequestId;
}
else if (match.Groups["build_number"].Value is string buildNum && int.TryParse(buildNum, out var build))
{
var buildInfo = await AppveyorClient.GetBuildInfoAsync(build, Config.Cts.Token).ConfigureAwait(false);
pr = buildInfo?.Build?.PullRequestId;
}
public static async Task OnMessageCreated(DiscordClient _, MessageCreateEventArgs args)
{
if (DefaultHandlerFilter.IsFluff(args.Message))
{
return;
}
/*
* (╯°□°）╯︵ ┻━┻
* (ノ ゜Д゜)ノ ︵ ┻━┻
* (ノಠ益ಠ)ノ彡┻━┻
* (ﾉಥ益ಥ）ﾉ ┻━┻
* (ﾉಥДಥ)ﾉ︵┻━┻･/
* (ノ^_^)ノ┻━┻
* (/¯◡ ‿ ◡)/¯ ~ ┻━┻
*
* this might look the same, but only because of the font choice
*
* ┻━┻
* ┻━┻
*/
try
{
var content = args.Message.Content;
if (!(content.Contains("┻━┻") ||
content.Contains("┻━┻")))
{
return;
}
var tableIdx = content.IndexOf("┻━┻");
if (tableIdx < 0)
{
tableIdx = content.IndexOf("┻━┻");
}
var faceIdx = content[..tableIdx].LastIndexOfAny(OpenParen);
public static async Task OnMessageCreated(DiscordClient c, MessageCreateEventArgs args)
{
if (DefaultHandlerFilter.IsFluff(args?.Message))
{
return;
}
#if !DEBUG
if (!(args.Channel.Id == Config.BotGeneralChannelId ||
args.Channel.Name.Equals("help", StringComparison.InvariantCultureIgnoreCase)))
{
return;
}
if (CooldownBuckets.TryGetValue(args.Channel.Id, out var lastCheck) &&
DateTime.UtcNow - lastCheck < CooldownThreshold)
{
return;
}
if (args.Author.IsSmartlisted(c, args.Guild))
{
return;
}
#endif
var matches = GameNameStatusMention1.Matches(args.Message.Content);
if (!matches.Any())
{
return;
}
var gameTitle = matches.Select(m => m.Groups["game_title_1"].Value)
.Concat(matches.Select(m => m.Groups["game_title_2"].Value))
.Concat(matches.Select(m => m.Groups["game_title_3"].Value))
.FirstOrDefault(t => !string.IsNullOrEmpty(t));
if (string.IsNullOrEmpty(gameTitle) || gameTitle.Length < 2)
{
return;
}
gameTitle = CompatList.FixGameTitleSearch(gameTitle);
if (gameTitle.Length < 4)
{
return;
}
if (ProductCodeLookup.ProductCode.IsMatch(args.Message.Content))
{
return;
}
var(_, info) = await LookupGameAsync(args.Channel, args.Message, gameTitle).ConfigureAwait(false);
if (string.IsNullOrEmpty(info?.Status))
{
return;
}
gameTitle = info.Title?.StripMarks();
if (string.IsNullOrEmpty(gameTitle))
{
return;
}
var botSpamChannel = await c.GetChannelAsync(Config.BotSpamId).ConfigureAwait(false);
var status = info.Status.ToLowerInvariant();
string msg;
if (status == "unknown")
{
msg = $"{args.Message.Author.Mention} {gameTitle} status is {status}";
}
else
{
if (status != "playable")
{
status += " (not playable)";
}
msg = $"{args.Message.Author.Mention} {gameTitle} is {status}";
if (!string.IsNullOrEmpty(info.Date))
{
msg += $" since {info.ToUpdated()}";
}
}
msg += $"\nfor more results please use compatibility list (<https://rpcs3.net/compatibility>) or `{Config.CommandPrefix}c` command in {botSpamChannel.Mention} (`!c {gameTitle.Sanitize()}`)";
await args.Channel.SendMessageAsync(msg).ConfigureAwait(false);
CooldownBuckets[args.Channel.Id] = DateTime.UtcNow;
}
public static async Task OnMessageCreated(DiscordClient c, MessageCreateEventArgs args)
{
if (DefaultHandlerFilter.IsFluff(args.Message))
{
return;
}
if ("media".Equals(args.Channel.Name, StringComparison.InvariantCultureIgnoreCase))
{
return;
}
var lastBotMessages = await args.Channel.GetMessagesBeforeAsync(args.Message.Id, 20, DateTime.UtcNow.AddSeconds(-30)).ConfigureAwait(false);
foreach (var msg in lastBotMessages)
{
if (BotReactionsHandler.NeedToSilence(msg).needToChill)
{
return;
}
}
lastBotMessages = await args.Channel.GetMessagesBeforeCachedAsync(args.Message.Id, Config.ProductCodeLookupHistoryThrottle).ConfigureAwait(false);
StringBuilder previousRepliesBuilder = null;
foreach (var msg in lastBotMessages)
{
if (msg.Author.IsCurrent)
{
previousRepliesBuilder ??= new StringBuilder();
previousRepliesBuilder.AppendLine(msg.Content);
var embeds = msg.Embeds;
if (embeds?.Count > 0)
{
foreach (var embed in embeds)
{
previousRepliesBuilder.AppendLine(embed.Title).AppendLine(embed.Description);
}
}
}
}
var previousReplies = previousRepliesBuilder?.ToString() ?? "";
var idsFromPreviousReplies = GetIssueIdsFromLinks(previousReplies);
var issuesToLookup = GetIssueIds(args.Message.Content)
.Where(lnk => !idsFromPreviousReplies.Contains(lnk))
.Take(args.Channel.IsPrivate ? 50 : 5)
.ToList();
if (issuesToLookup.Count == 0)
{
return;
}
var suffix = issuesToLookup.Count == 1 ? "" : "s";
if (GithubClient.Client.RateLimitRemaining - issuesToLookup.Count >= 10)
{
foreach (var issueId in issuesToLookup)
{
await Pr.LinkIssue(c, args.Message, issueId).ConfigureAwait(false);
}
}
else
{
var result = new StringBuilder($"Link{suffix} to the mentioned issue{suffix}:");
foreach (var issueId in issuesToLookup)
{
result.AppendLine().Append("https://github.com/RPCS3/rpcs3/issues/" + issueId);
}
await args.Channel.SendAutosplitMessageAsync(result, blockStart : null, blockEnd : null).ConfigureAwait(false);
}
}
public static async Task OnMessageCreated(MessageCreateEventArgs args)
{
if (DefaultHandlerFilter.IsFluff(args.Message))
{
return;
}
if (args.Message.Channel.IsPrivate)
{
return;
}
#if DEBUG
if (args.Message.Content == "emoji test")
{
var badEmojis = new List <DiscordEmoji>(SadReactions.Concat(ThankYouReactions));
var posted = 0;
var line = 1;
var msg = await args.Channel.SendMessageAsync("Line " + line).ConfigureAwait(false);
for (var i = 0; i < 5; i++)
{
var tmp = new List <DiscordEmoji>();
foreach (var emoji in badEmojis)
{
try
{
await msg.CreateReactionAsync(emoji).ConfigureAwait(false);
if (++posted == 15)
{
line++;
posted = 0;
msg = await args.Channel.SendMessageAsync("Line " + line).ConfigureAwait(false);
}
}
catch (Exception e)
{
Config.Log.Debug(e);
tmp.Add(emoji);
}
}
badEmojis = tmp;
if (badEmojis.Any())
{
await Task.Delay(1000).ConfigureAwait(false);
}
}
if (badEmojis.Any())
{
await args.Channel.SendMessageAsync("Bad emojis: " + string.Concat(badEmojis)).ConfigureAwait(false);
}
else
{
await args.Channel.SendMessageAsync("Everything looks fine").ConfigureAwait(false);
}
return;
}
#endif
var(needToSilence, needToThank) = NeedToSilence(args.Message);
if (!(needToSilence || needToThank))
{
return;
}
if (needToThank)
{
DiscordEmoji emoji;
string thankYouMessage;
lock (theDoor)
{
emoji = ThankYouReactions[rng.Next(ThankYouReactions.Length)];
thankYouMessage = LimitedToSpamChannel.IsSpamChannel(args.Channel) ? ThankYouMessages[rng.Next(ThankYouMessages.Length)] : null;
}
await args.Message.ReactWithAsync(emoji, thankYouMessage).ConfigureAwait(false);
}
if (needToSilence)
{
DiscordEmoji emoji;
string sadMessage;
lock (theDoor)
{
emoji = SadReactions[rng.Next(SadReactions.Length)];
sadMessage = SadMessages[rng.Next(SadMessages.Length)];
}
await args.Message.ReactWithAsync(emoji, sadMessage).ConfigureAwait(false);
if (args.Author.IsSmartlisted(args.Client, args.Message.Channel.Guild))
{
var botMember = args.Guild?.CurrentMember ?? args.Client.GetMember(args.Client.CurrentUser);
if (args.Channel.PermissionsFor(botMember).HasPermission(Permissions.ReadMessageHistory))
{
var lastBotMessages = await args.Channel.GetMessagesBeforeAsync(args.Message.Id, 20, DateTime.UtcNow.Add(-Config.ShutupTimeLimit)).ConfigureAwait(false);
if (lastBotMessages.OrderByDescending(m => m.CreationTimestamp).FirstOrDefault(m => m.Author.IsCurrent) is DiscordMessage msg)
{
await msg.DeleteAsync("asked to shut up").ConfigureAwait(false);
}
}
else
{
await args.Message.ReactWithAsync(DiscordEmoji.FromUnicode("🙅"), @"No can do, boss ¯\\_(ツ)\_/¯").ConfigureAwait(false);
}
}
}
}
public static async Task OnMessageCreated(MessageCreateEventArgs args)
{
if (DefaultHandlerFilter.IsFluff(args.Message))
{
return;
}
if (args.Channel.IsPrivate)
{
return;
}
if (args.Author.IsCurrent)
{
return;
}
if (args.Author.Id == 197163728867688448ul)
{
return;
}
if (!MessageQueue.TryGetValue(args.Channel.Id, out var queue))
{
MessageQueue[args.Channel.Id] = queue = new ConcurrentQueue <DiscordMessage>();
}
queue.Enqueue(args.Message);
while (queue.Count > 10)
{
queue.TryDequeue(out _);
}
var content = args.Message.Content;
if (string.IsNullOrEmpty(content))
{
return;
}
if (Throttling.TryGetValue(args.Channel.Id, out List <DiscordMessage> mark) && content.Equals(mark.FirstOrDefault()?.Content, StringComparison.OrdinalIgnoreCase))
{
mark.Add(args.Message);
Config.Log.Debug($"Bailed out of repeating '{content}' due to throttling");
return;
}
var similarList = queue.Where(msg => content.Equals(msg.Content, StringComparison.OrdinalIgnoreCase)).ToList();
if (similarList.Count > 2)
{
var uniqueUsers = similarList.Select(msg => msg.Author.Id).Distinct().Count();
if (uniqueUsers > 2)
{
Throttling.Set(args.Channel.Id, similarList, ThrottleDuration);
var msgContent = GetAvgContent(similarList.Select(m => m.Content).ToList());
var botMsg = await args.Channel.SendMessageAsync(msgContent).ConfigureAwait(false);
similarList.Add(botMsg);
}
else
{
Config.Log.Debug($"Bailed out of repeating '{content}' due to {uniqueUsers} unique users");
}
}
}
private static async Task CheckMessageForInvitesAsync(DiscordClient client, DiscordMessage message)
{
if (DefaultHandlerFilter.IsFluff(message))
{
return;
}
if (message.Author.IsWhitelisted(client, message.Channel.Guild))
{
return;
}
if (message.Reactions.Any(r => r.Emoji == Config.Reactions.Moderated && r.IsMe))
{
return;
}
var(hasInvalidResults, invites) = await client.GetInvitesAsync(message.Content).ConfigureAwait(false);
if (!hasInvalidResults && invites.Count == 0)
{
return;
}
if (hasInvalidResults)
{
try
{
await message.DeleteAsync("Not a white-listed discord invite link").ConfigureAwait(false);
await client.ReportAsync("An unapproved discord invite", message, "In invalid or expired invite", null, ReportSeverity.Low).ConfigureAwait(false);
await message.Channel.SendMessageAsync($"{message.Author.Mention} please refrain from posting invites that were not approved by a moderator, especially expired or invalid.").ConfigureAwait(false);
}
catch (Exception e)
{
Config.Log.Warn(e);
await client.ReportAsync("An unapproved discord invite", message, "In invalid or expired invite", null, ReportSeverity.Medium).ConfigureAwait(false);
await message.ReactWithAsync(
client,
Config.Reactions.Moderated,
$"{message.Author.Mention} please remove this expired or invalid invite, and refrain from posting it again until you have recieved an approval from a moderator.",
true
).ConfigureAwait(false);
}
return;
}
foreach (var invite in invites)
{
if (!await InviteWhitelistProvider.IsWhitelistedAsync(invite).ConfigureAwait(false))
{
try
{
await message.DeleteAsync("Not a white-listed discord invite link").ConfigureAwait(false);
await client.ReportAsync("An unapproved discord invite", message, $"Invite {invite.Code} was resolved to the {invite.Guild.Name} server", null, ReportSeverity.Low).ConfigureAwait(false);
await message.Channel.SendMessageAsync($"{message.Author.Mention} invites to the {invite.Guild.Name.Sanitize()} server are not whitelisted.\n" +
$"Please refrain from posting it again until you have recieved an approval from a moderator.").ConfigureAwait(false);
}
catch (Exception e)
{
Config.Log.Warn(e);
await client.ReportAsync("An unapproved discord invite", message, $"Invite {invite.Code} was resolved to the {invite.Guild.Name} server", null, ReportSeverity.Medium).ConfigureAwait(false);
await message.ReactWithAsync(
client,
Config.Reactions.Moderated,
$"{message.Author.Mention} invites to the {invite.Guild.Name.Sanitize()} server are not whitelisted.\n" +
$"Please remove it and refrain from posting it again until you have recieved an approval from a moderator.",
true
).ConfigureAwait(false);
}
return;
}
}
}
public static async Task OnMessageCreated(DiscordClient c, MessageCreateEventArgs args)
{
if (DefaultHandlerFilter.IsFluff(args.Message))
{
return;
}
if (args.Message.Channel.IsPrivate)
{
return;
}
#if DEBUG
if (args.Message.Content == "emoji test")
{
var badEmojis = new List <DiscordEmoji>(SadReactions.Concat(ThankYouReactions));
var posted = 0;
var line = 1;
var msg = await args.Channel.SendMessageAsync("Line " + line).ConfigureAwait(false);
for (var i = 0; i < 5; i++)
{
var tmp = new List <DiscordEmoji>();
foreach (var emoji in badEmojis)
{
try
{
await msg.CreateReactionAsync(emoji).ConfigureAwait(false);
if (++posted == 15)
{
line++;
posted = 0;
msg = await args.Channel.SendMessageAsync("Line " + line).ConfigureAwait(false);
}
}
catch (Exception e)
{
Config.Log.Debug(e);
tmp.Add(emoji);
}
}
badEmojis = tmp;
if (badEmojis.Any())
{
await Task.Delay(1000).ConfigureAwait(false);
}
}
if (badEmojis.Any())
{
await args.Channel.SendMessageAsync("Bad emojis: " + string.Concat(badEmojis)).ConfigureAwait(false);
}
else
{
await args.Channel.SendMessageAsync("Everything looks fine").ConfigureAwait(false);
}
return;
}
#endif
if (!string.IsNullOrEmpty(args.Message.Content) && Paws.Matches(args.Message.Content) is MatchCollection mc)
{
using var db = new BotDb();
var matchedGroups = (from m in mc
from Group g in m.Groups
where g.Success && !string.IsNullOrEmpty(g.Value)
select g.Name
).Distinct()
.ToArray();
if (matchedGroups.Contains("kot"))
{
if (!db.Kot.Any(k => k.UserId == args.Author.Id))
{
db.Kot.Add(new Kot {
UserId = args.Author.Id
});
await db.SaveChangesAsync().ConfigureAwait(false);
}
}
if (matchedGroups.Contains("doggo"))
{
if (!db.Doggo.Any(d => d.UserId == args.Author.Id))
{
db.Doggo.Add(new Doggo {
UserId = args.Author.Id
});
await db.SaveChangesAsync().ConfigureAwait(false);
}
}
}
var(needToSilence, needToThank) = NeedToSilence(args.Message);
if (!(needToSilence || needToThank))
{
return;
}
if (needToThank)
{
DiscordEmoji emoji;
string thankYouMessage;
lock (theDoor)
{
emoji = ThankYouReactions[rng.Next(ThankYouReactions.Length)];
thankYouMessage = LimitedToSpamChannel.IsSpamChannel(args.Channel) ||
LimitedToOfftopicChannel.IsOfftopicChannel(args.Channel)
? ThankYouMessages[rng.Next(ThankYouMessages.Length)]
: null;
}
await args.Message.ReactWithAsync(emoji, thankYouMessage).ConfigureAwait(false);
}
if (needToSilence)
{
DiscordEmoji emoji;
string sadMessage;
lock (theDoor)
{
emoji = SadReactions[rng.Next(SadReactions.Length)];
sadMessage = SadMessages[rng.Next(SadMessages.Length)];
}
await args.Message.ReactWithAsync(emoji, sadMessage).ConfigureAwait(false);
if (args.Author.IsSmartlisted(c, args.Message.Channel.Guild))
{
var botMember = args.Guild?.CurrentMember ?? c.GetMember(c.CurrentUser);
if (args.Channel.PermissionsFor(botMember).HasPermission(Permissions.ReadMessageHistory))
{
var lastBotMessages = await args.Channel.GetMessagesBeforeAsync(args.Message.Id, 20, DateTime.UtcNow.Add(-Config.ShutupTimeLimitInMin)).ConfigureAwait(false);
if (lastBotMessages.OrderByDescending(m => m.CreationTimestamp).FirstOrDefault(m => m.Author.IsCurrent) is DiscordMessage msg)
{
await msg.DeleteAsync("asked to shut up").ConfigureAwait(false);
}
}
else
{
await args.Message.ReactWithAsync(DiscordEmoji.FromUnicode("🙅"), @"No can do, boss ¯\\_(ツ)\_/¯").ConfigureAwait(false);
}
}
}
}
public static async Task OnMessageCreated(MessageCreateEventArgs args)
{
if (DefaultHandlerFilter.IsFluff(args.Message))
{
return;
}
/*
* (╯°□°）╯︵ ┻━┻
* (ノ ゜Д゜)ノ ︵ ┻━┻
* (ノಠ益ಠ)ノ彡┻━┻
* (ﾉಥ益ಥ）ﾉ ┻━┻
* (ﾉಥДಥ)ﾉ︵┻━┻･/
* (ノ^_^)ノ┻━┻
* (/¯◡ ‿ ◡)/¯ ~ ┻━┻
*
* this might look the same, but only because of the font choice
*
* ┻━┻
* ┻━┻
*/
try
{
var content = args.Message.Content;
if (!(content.Contains("┻━┻") ||
content.Contains("┻━┻")))
{
return;
}
var tableIdx = content.IndexOf("┻━┻");
if (tableIdx < 0)
{
tableIdx = content.IndexOf("┻━┻");
}
var faceIdx = content.Substring(0, tableIdx).LastIndexOfAny(OpenParen);
var face = content.Substring(faceIdx, tableIdx - faceIdx);
if (face.Length > 30)
{
return;
}
var reverseFace = face
.Replace("(╯", "╯(").Replace("(ﾉ", "ﾉ(").Replace("(ノ", "ノ(").Replace("(/¯", @"\_/(")
.Replace(")╯", "╯)").Replace(")ﾉ", "ﾉ)").Replace(")ノ", "ノ)").Replace(")/¯", @"\_/)")
.Replace("（╯", "╯（").Replace("（ﾉ", "ﾉ（").Replace("（ノ", "ノ（").Replace("（/¯", @"\_/（")
.Replace("）╯", "╯）").Replace("）ﾉ", "ﾉ）").Replace("）ノ", "ノ）").Replace("）/¯", @"\_/）")
.Replace("ʕ╯", "╯ʕ").Replace("ʕﾉ", "ﾉʕ").Replace("ʕノ", "ノʕ").Replace("ʕ/¯", @"\_/ʕ")
.Replace("ʔ╯", "╯ʔ").Replace("ʔﾉ", "ﾉʔ").Replace("ʔノ", "ノʔ").Replace("ʔ/¯", @"\_/ʔ")
.TrimEnd('︵', '彡', ' ', ' ', '~', '～');
if (reverseFace == face)
{
return;
}
var faceLength = reverseFace.Length;
if (faceLength > 5 + 4)
{
reverseFace = $"{reverseFace.Substring(0, 2)}ಠ益ಠ{reverseFace.Substring(faceLength - 2, 2)}";
}
await args.Channel.SendMessageAsync("┬─┬ " + reverseFace.Sanitize()).ConfigureAwait(false);
}
catch (Exception e)
{
Config.Log.Warn(e);
}
}
