public override async Task Execute(DiscordSocketClient client, SocketMessage message)
{
var guild = client.GetGuild(GetApplicableGuildId());
var sadge = await guild.GetEmoteAsync(845161446547521566);
await Task.WhenAll(message.AddReactionAsync(sadge), message.AddReactionAsync(new Emoji("🦶")));
}
private async Task OnMessageReceived(SocketMessage message)
{
if (message.Author.Id == this.Client.DiscordClient.CurrentUser.Id)
{
return;
}
if (!(message.Channel is SocketDMChannel)) //Not a PM
{
return;
}
try
{
ITextChannel channel = await FindOrCreateThread(message.Author.Id, true, true);
if (channel == null)
{
return;
}
Embed embed = GetMessageEmbed(message);
await SendThreadReply(channel, message.Id, embed : embed);
await message.AddReactionAsync(new Emoji("✅"));
}
catch (Exception e)
{
await this.HandleException(e, "OnMessageReceived", 0);
await message.AddReactionAsync(new Emoji("❌"));
}
}
private async Task <bool> HahaFunni(SocketMessage m)
{
if (m.Content.Equals("good bot", StringComparison.OrdinalIgnoreCase))
{
await m.AddReactionAsync(Emote.Parse(_pairs.GetString("AGRLOVE_EMOTE")));
}
else if (m.Content.Equals("bad bot", StringComparison.OrdinalIgnoreCase))
{
await m.AddReactionAsync(Emote.Parse(_pairs.GetString("SAD_EMOTE")));
}
else if (m.Content.Equals(_pairs.GetString("THANKS_THORN_TRIGGER"), StringComparison.OrdinalIgnoreCase))
{
await m.AddReactionAsync(Emote.Parse(_pairs.GetString("AGRLOVE_EMOTE")));
}
else if (m.Content.Equals(_pairs.GetString("BODIES_IN_WATER_TRIGGER"), StringComparison.OrdinalIgnoreCase))
{
await m.Channel.SendMessageAsync(_random.Next(2) == 0?
_pairs.GetString("BODIES_IN_WATER_ERROR") :
_pairs.GetString("BODIES_IN_WATER_SUCCESS"));
}
else if (m.Content.Equals(_pairs.GetString("BODIES_IN_WATER_OHGODOHFUCK_TRIGGER"), StringComparison.OrdinalIgnoreCase))
{
await m.Channel.SendMessageAsync(_pairs.GetString("BODIES_IN_WATER_OHGODOHFUCK"));
}
else
{
return(false);
}
return(true);
}
public static async Task PatMessage(SocketMessage message)
{
await message.Channel.SendMessageAsync(getPatResponse());
await message.AddReactionAsync(new Emoji("\u267F"));
await message.AddReactionAsync(new Emoji("\uD83C\uDF08"));
}
static async Task CumOnMessage(SocketMessage message)
{
var r = new Random();
if (r.NextDouble() > 0.98)
{
await message.AddReactionAsync(new Emoji("\uD83C\uDDE8"));
await message.AddReactionAsync(new Emoji("\uD83C\uDDFA"));
await message.AddReactionAsync(new Emoji("\uD83C\uDDF2"));
_logger.LogInformation($"cummed on '{message.Content}' from {message.Author.Username}#{message.Author.Discriminator} in #{message.Channel.Name}");
}
}
/// <summary>
/// The handler for any audit related commands.
/// </summary>
/// <param name="message">The message sent</param>
/// <returns></returns>
private async Task OnMessage(SocketMessage message)
{
// Only human administrators can manage the role assignment channel.
if (message.Author.IsBot || !(message.Author as SocketGuildUser).GuildPermissions.Administrator)
{
return;
}
var channel = message.Channel as SocketTextChannel;
if (channel == null)
{
return;
}
var guild = GuildRepo.Get(channel.Guild.Id);
var parts = message.Content.Split();
if (parts[0] == $"{guild.Settings.Prefix}setAuditChannel")
{
GuildRepo.SetAuditLogChannel(guild.Id, message.Channel.Id);
await message.AddReactionAsync(new Emoji("\uD83D\uDC4D"));
}
}
public override async Task Execute(DiscordSocketClient client, SocketMessage message)
{
var guild = client.GetGuild(GetApplicableGuildId());
var banish = await guild.GetEmoteAsync(846589900719259648);
await message.AddReactionAsync(banish);
}
public async Task HandleAsync(SocketMessage message)
{
if (message.Author.IsBot)
{
return;
}
if (message.Content.ToUpper() != "CAD")
{
return;
}
if (message.Attachments.Count < 1)
{
return;
}
var client = await _clientTaskLazy.Value;
var isDryRun = message.Content.ToUpper() != message.Content;
await message.AddReactionAsync(new Emoji("⏳"));
await _bus.DispatchAsync(
new DetectionRequest(message.Attachments.First().Url),
new DiscordContext(isDryRun, client.CurrentUser, message, message.Channel)
);
}
private async Task OnMessageReceived(SocketMessage msg)
{
if (msg.Author.IsBot)
{
return;
}
var usrId = msg.Author.Id;
if (!CanVote(usrId))
{
_logger.LogError($"User {usrId} - {msg.Author.Username} can't vote");
return;
}
if (msg.Channel is SocketDMChannel dmChannel)
{
await msg.AddReactionAsync(Constants.OkEmoji);
List <Vote> res = ProcessVote(msg.Content);
var formatted = String.Join("\n", res.Select(v => $"{v.Value} puntos para {v.Candidate.Name}"));
if (String.IsNullOrEmpty(formatted))
{
formatted = "No te entiendo. Si reaccionas, tu voto no será válido.";
await dmChannel.SendMessageAsync(formatted);
return;
}
var m = "Esto es lo que he entendido:\n";
var f = "\nReacciona a tu propio mensaje con ✅ para guardar el voto. No podrás cambiarlo una vez guardado.";
await dmChannel.SendMessageAsync(m + formatted + f);
}
}
public override async Task Execute(DiscordSocketClient client, SocketMessage message)
{
var guild = client.GetGuild(GetApplicableGuildId());
var emote = await guild.GetEmoteAsync(573531927613800459); // SCH emote
await message.AddReactionAsync(emote);
}
protected async Task <Task> MarkMessage(SocketMessage message, string emote)
{
var Tickmark = new Emoji(emote);
await message.AddReactionAsync(Tickmark, RequestOptions.Default);
return(Task.CompletedTask);
}
public override async Task Execute(DiscordSocketClient client, SocketMessage message)
{
var emotes = new[] { new Emoji("↖️"), new Emoji("↙️"), new Emoji("↘️"), new Emoji("↗️") };
foreach (var emote in emotes)
{
await message.AddReactionAsync(emote);
}
}
private async Task MessageReceived(SocketMessage message)
{
string content = message.Content.ToLower();
if (content == "!ping")
{
await message.Channel.SendMessageAsync("Pong!");
}
else if (content.Contains("cry") || content.Contains("cri"))
{
await message.AddReactionAsync(Emote.Parse("<:cry:674774877550411786>"));
}
else if (content.Contains("cool") || content.Contains("kool"))
{
await message.AddReactionAsync(Emote.Parse("<:coolio:625922857997959178>"));
await message.AddReactionAsync(Emote.Parse("<:cool_guy:625924283272527882>"));
}
}
//on message received
private async Task MessageReceived(SocketMessage message)
{
//for words in bad word list
foreach (String word in words)
{
//if the message contains the word
if (message.Content.ToLower().Contains(word))
{
//log it to console
Console.WriteLine($"{message.Author.Username} swore!");
//React with :eyes:
await message.AddReactionAsync(new Emoji("👀"));
//get guild by name, because this is the easiest way to do it.
var chnl = message.Channel as SocketGuildChannel;
var Guild = chnl.Guild.Name;
//Log it to log.txt
StreamWriter log = new StreamWriter("Log.txt", append: true); //open streamwriter
await log.WriteLineAsync($"{message.Author.Id} as {message.Author.Username} in {Guild} at {DateTime.Now} said a banned word in message \"{message.Content}\""); //write line
log.Close(); //close the streamwriter
}
}
//check if msg calls to swearcount
if (message.Content.StartsWith("!swearcount"))
{
//if it does, get the first mentioned person
if (message.MentionedUsers != null)
{
int occurences = 0;
//get their id
String targetID = message.MentionedUsers.ElementAt(0).Id.ToString();
//read log and split it into array
string[] lines = File.ReadAllLines("Log.txt");
//go through the logs and check
foreach (string line in lines)
{
//count how often the specified user is in the logs
if (line.StartsWith(targetID))
{
occurences++;
}
}
//send a message back
await message.Channel.SendMessageAsync($"user {targetID} as {message.MentionedUsers.ElementAt(0).Username} has said bannned words {occurences} times!");
}
else
{
await message.Channel.SendMessageAsync("Invalid mention!");
}
}
}
private async Task HandleThankMention(SocketMessage message)
{
IReadOnlyCollection <SocketUser> mentions = message.MentionedUsers;
if (mentions.Count == 0)
{
return;
}
string[] thankMatches = { "thank", "ty", "thx", "appreciate", "cheers" };
if (!message.Content.ToLower().ContainsAny(thankMatches))
{
return;
}
string steamId = _identity.DiscordToSteam.GetOrDefault($"{message.Author.Id}");
if (steamId == "")
{
return;
}
var user = UserManager.FindUserBySteamId(steamId);
if (user == null || user.Player == null)
{
return;
}
foreach (SocketUser mention in mentions)
{
if (mention.Id == message.Author.Id)
{
continue;
}
string mentionSteamId = _identity.DiscordToSteam.GetOrDefault($"{mention.Id}");
if (mentionSteamId == "")
{
continue;
}
var mentionUser = UserManager.FindUserBySteamId(mentionSteamId);
if (mentionUser == null)
{
continue;
}
user.Player.GiveReputationTo(mentionUser.Name, 1, message.Content);
await _debug.SendMessageAsync($"{message.Author.Mention} gave {mention.Mention} 1 reputation by thanking them in a mention.");
}
await message.AddReactionAsync(new Emoji("🏅"));
}
private static async Task MessageReceived(SocketMessage msg)
{
if (msg.Content == "1")
{
await msg.Channel.SendMessageAsync(
text : "Заебал. Ну скажи уже блядь по человечески шо ты хочешь, Хлопчик",
messageReference : msg.Reference
);
await msg.AddReactionAsync(Emoji.Parse("⚧"));
}
}
public static async Task MessageReceived(SocketMessage message)
{
SocketUser user = message.Author;
using (VooperContext context = new VooperContext(VoopAI.DBOptions))
{
User userData = context.Users.FirstOrDefault(u => u.discord_id == user.Id);
if (userData != null && userData.Id == "u-be323eec-014a-420c-afd5-cddfe308b8c4")
{
message.AddReactionAsync(yeahok);
}
if (!(message.Channel is SocketDMChannel))
{
if (userData != null)
{
userData.discord_message_count += 1;
if (!message.Author.IsBot)
{
// In this case it's been a minute since the last message
if (DateTime.Now.Minute != userData.discord_last_message_minute)
{
// Give message XP
userData.discord_message_xp++;
userData.discord_last_message_minute = DateTime.Now.Minute;
userData.Discord_Last_Message_Time = DateTime.UtcNow;
}
}
await context.SaveChangesAsync();
}
}
}
if (message.Channel.Id == VoopAI.botChannel.Id)
{
//VoopAI.logger.LogInformation("Recieved message in Bot channel.");
await OnMessageBotChannel(message);
}
else if (message.Channel.GetType() == typeof(SocketDMChannel))
{
//VoopAI.logger.LogInformation("Recieved message in DM.");
await OnMessageDM(message);
}
await OnMessageChannel(message);
await ChatFilter.FilterMessage(message);
}
async Task OnProposalReceivedAsync(SocketMessage message)
{
var userId = message.Author.Id;
if (!Config.PhotoUserIds.Contains(userId))
{
await message.DeleteAsync();
return;
}
Config.Proposals ??= new List <PhotoMessage>();
if (Config.Proposals.Any(element => element.UserId == userId))
{
await message.DeleteAsync();
return;
}
var proposal = new PhotoMessage
{
MessageId = message.Id,
UserId = userId,
Topic = message.Content,
ImageUrl = message.Attachments.ElementAt(0).Url,
};
Config.Proposals.Add(proposal);
Console.WriteLine($"Added new proposal from user {proposal.UserId} with topic {proposal.Topic} and image {proposal.ImageUrl}");
await message.AddReactionAsync(new Emoji("✅"));
await message.AddReactionAsync(new Emoji("❌"));
await message.AddReactionAsync(new Emoji("🚫"));
await PhotoConfig.SaveAsync();
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
private async Task Client_MessageReceived(SocketMessage msg)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
if (!Config.ImageChannelIds.Contains(msg.Channel.Id))
{
return;
}
if (r.IsMatch(msg.Content))
{
_ = msg.DeleteAsync();
var res = msg.Channel.SendMessageAsync(":x: URLs are not allowed, Senpai. Please upload your image/gif directly to the channel.");
_ = Task.Delay(15 * 1000).ContinueWith(a => res.Result.DeleteAsync());
return;
}
if (msg.Attachments.Any())
{
_ = msg.AddReactionAsync(Emote.Parse("<:TickYes:577838859107303424>"));
_ = msg.AddReactionAsync(Emote.Parse("<:TickNo:577838859077943306>"));
}
}
public async Task FunnyReaction(SocketMessage msg)
{
//Check if system message
if (!(msg is SocketUserMessage message))
{
return;
}
//check if user is the source of msg
if (message.Source != Discord.MessageSource.User)
{
return;
}
//Get emotes
var emote = await GetEmote("49");
if (msg.Channel.Id == 347154413124583424)
{
if (msg.Content.Length == 0)
{
await msg.AddReactionAsync(emote);
Console.WriteLine("Pic Detected");
}
}
#region Fun responses
if (msg.Content.ToLower() == "reich")
{
await msg.Channel.SendMessageAsync("Oh not again...");
}
else if (msg.Content.ToLower().Contains("omg"))
{
await msg.Channel.SendMessageAsync("No way D:");
}
string[] lewdWords = new string[]
{
"lewd", "panties", "yaoi", "p**n", "hentai"
};
if (lewdWords.Any(x => x.Equals(msg.Content, StringComparison.OrdinalIgnoreCase)))
{
await msg.Channel.SendMessageAsync("( ͡° ͜ʖ ͡°)");
}
#endregion
}
private async Task OnMessageUpdated(IMessage originalMessage, SocketMessage updatedMessage, ISocketMessageChannel _)
{
if (originalMessage.Content == updatedMessage.Content)
{
return;
}
if (updatedMessage.Author.Id == this.Client.DiscordClient.CurrentUser.Id)
{
return;
}
if (!(updatedMessage.Channel is SocketDMChannel)) //Not a PM
{
return;
}
try
{
await updatedMessage.RemoveAllReactionsAsync();
ITextChannel channel = await FindOrCreateThread(updatedMessage.Author.Id, true, true);
if (channel == null)
{
return;
}
Embed embed = GetMessageEmbed(updatedMessage);
await SendThreadReply(channel, updatedMessage.Id, embed : embed);
await updatedMessage.AddReactionAsync(new Emoji("✅"));
}
catch (Exception e)
{
await this.HandleException(e, "OnMessageReceived", 0);
await updatedMessage.AddReactionAsync(new Emoji("❌"));
}
}
/// <summary>
/// Submits the message to the first handler which can handle it. If none can, communicates to the user the
/// message was not understood.
/// </summary>
/// <param name="message">The message from the user. May not be null.</param>
/// <param name="handlers">Any list of handlers. May not be null.</param>
/// <returns>When the message has been handled.</returns>
private async Task HandleMessage(SocketMessage message, IReadOnlyList <IMessageHandler> handlers)
{
var handleResult = CommandEngine.handleResultPool.Get();
try
{
bool wasHandled = false;
for (int i = 0; i < handlers.Count && !wasHandled; i += 1)
{
var handler = handlers[i];
var canHandle = await handler.CanHandleMessage(message, recycleResult : handleResult)
.ConfigureAwait(false);
switch (canHandle.Status)
{
case CanHandleResult.ResultStatus.Handleable:
wasHandled = true;
await handler.HandleMessage(message, canHandle.HandleCache).ConfigureAwait(false);
break;
case CanHandleResult.ResultStatus.TimedOut:
Logger.LogWarning(
"Handler timed out;{{handlerType:{handlerType},timeoutPeriod:{timeoutPeriod},message:{message}}}",
handler.GetType().Name,
canHandle.TimeOutPeriod,
message.Content);
continue;
case CanHandleResult.ResultStatus.Unhandleable:
continue;
default:
throw new NotImplementedException(canHandle.Status.ToString());
}
}
if (!wasHandled)
{
await message.AddReactionAsync(NoMatchEmoji).ConfigureAwait(false);
}
}
finally
{
handleResult.ClearReferences();
CommandEngine.handleResultPool.Return(handleResult);
}
}
private async Task RemoveResponse(Guild guild, SocketMessage message)
{
var parts = message.Content.Split();
if (parts.Length < 2)
{
await message.Channel.SendMessageAsync($"```Usage: {guild.Settings.Prefix}removeResponse <message>```");
return;
}
_guildRepo.RemoveAutoResponse(guild.Id, parts[1]);
await message.AddReactionAsync(new Emoji("\uD83D\uDC4D"));
}
private async Task AddResponse(Guild guild, SocketMessage message)
{
var parts = message.Content.Split(' ', StringSplitOptions.RemoveEmptyEntries);
if (parts.Length < 3)
{
await message.Channel.SendMessageAsync($"```Usage: {guild.Settings.Prefix}addResponse <message> <response>```");
return;
}
_guildRepo.AddAutoResponse(guild.Id, parts[1], string.Join(' ', parts.Skip(2)));
await message.AddReactionAsync(new Emoji("\uD83D\uDC4D"));
}
async Task Assign(SocketMessage message, string lowercase)
{
string[] data = lowercase.Split(" ");
if (data.Length >= 5)
{
var emoji = new Emoji(data[3]);
try
{
await message.AddReactionAsync(emoji);
if (message.MentionedRoles.Count() == 1)
{
ulong roleID = message.MentionedRoles.First().Id;
if (message.Channel is SocketGuildChannel)
{
var guildID = (message.Channel as SocketGuildChannel).Guild.Id;
if (!rolesForServers.ContainsKey(guildID.ToString()))
{
rolesForServers[guildID.ToString()] = new List <EmojiAndRole>();
}
rolesForServers[guildID.ToString()].Add(new EmojiAndRole {
ID = roleID, emoji = data[3]
});
await message.Channel.SendMessageAsync($"{roleID} given {emoji}");
}
else
{
await message.Channel.SendMessageAsync("action must be performed in a discord server/guild");
}
}
else
{
await message.Channel.SendMessageAsync("invalid number of mentions");
}
}
catch (Exception e)
{
await message.Channel.SendMessageAsync("invalid emoji type");
}
SaveAndLoad.SaveFile(rolesForServers, Directory.GetCurrentDirectory(), reactionRolesPath);
}
else
{
await message.Channel.SendMessageAsync($"Something went wrong");
}
}
public async Task MessageReceivedAsync(SocketMessage rawMessage)
{
// Ignore system messages, or messages from other bots
if (!(rawMessage is SocketUserMessage message))
{
return;
}
if (message.Source != MessageSource.User)
{
return;
}
if (_rand.Next(0, 10) == 0)
{
SocketGuild guild = ((SocketGuildChannel)rawMessage.Channel).Guild;
IEmote emote = guild.Emotes.FirstOrDefault(e => e.Name == "ronners");
if (emote is not null)
{
await rawMessage.AddReactionAsync(emote);
}
await _services.GetRequiredService <GameService>().AddRonPoints(rawMessage.Author, 10);
}
// This value holds the offset where the prefix ends
var argPos = 0;
// Perform prefix check. You may want to replace this with
// for a more traditional command format like !help.
if (!message.HasCharPrefix(ConfigService.Config.CommandPrefix, ref argPos))
{
return;
}
var context = new SocketCommandContext(_discord, message);
// Perform the execution of the command. In this method,
// the command service will perform precondition and parsing check
// then execute the command if one is matched.
await _commands.ExecuteAsync(context, argPos, _services);
// Note that normally a result will be returned by this format, but here
// we will handle the result in CommandExecutedAsync,
}
public async Task NewMessageReceived(SocketMessage message)
{
if (message.Author.IsBot)
{
return;
}
var prediction = await _robot.IsThisToxic(message.Content);
if (prediction.Prediction)
{
Console.WriteLine($"{message.Content} is {prediction.Prediction}");
await message.AddReactionAsync(new Emoji("\uD83D\uDE21"));
}
return;
}
public static async Task Handler(DiscordSocketClient client, SocketMessage message)
{
if (message.Content == "(╯°□°）╯︵ ┻━┻")
{
await message.Channel.SendMessageAsync("┬─┬ ノ( ゜-゜ノ)");
return;
}
if (HasWord(message.Content, "sch") || HasWord(message.Content, "scholar"))
{
var guild = client.GetGuild(SpecialGuilds.CrystalExploratoryMissions);
var emote = await guild.GetEmoteAsync(573531927613800459); // SCH emote
await message.AddReactionAsync(emote);
}
}
private static async Task Client_OnMessageReceived(SocketMessage message)
{
var user = message.Author as SocketGuildUser;
var requiredRole = (user as IGuildUser).Guild.Roles.FirstOrDefault(x => x.Name == "~Moderator~");
if (user.Roles.Contains(requiredRole))
{
var messageSend = new TwitchMessage(message.Author.Username, message.Content);
if (messageSend.BotResponse != null && messageSend.BotResponse.Length > 0)
{
if (!BotTools.Settings["debug_output"])
{
await message.Channel.SendMessageAsync(String.Join("\n", messageSend.BotResponse));
}
else
{
BotTools.LogLine("[D] RazBot: " + String.Join("\n", messageSend.BotResponse));
}
}
else if (messageSend.WitResponse != null && messageSend.WitResponse.Length > 0)
{
if (!BotTools.Settings["debug_output"])
{
await message.Channel.SendMessageAsync(String.Join("\n", messageSend.WitResponse));
}
else
{
BotTools.LogLine("[D] RazBot: " + String.Join("\n", messageSend.WitResponse));
}
}
}
while (RequestPosting)
{
;
}
if (RequestMap.ContainsKey(message.Id))
{
foreach (var emoji in new[] { "👍", "👎" }) // "✅" "▶️" // "👍" "👎" // "⛔" "⏏️"
{
await message.AddReactionAsync(new Emoji(emoji));
}
}
}
private async Task SortOutMessageTypeAsync(SocketMessage message)
{
foreach (IHandleableMessage handler in _handlers)
{
if (await handler.HandleAsync(message) == false)
{
continue;
}
if (_chatBehaviour.DeleteMessages)
{
await message.DeleteAsync();
}
return;
}
await message.AddReactionAsync(new Emoji("🤷♂️"));
}
