public async Task MessageReceiveAsync(Discord.WebSocket.SocketMessage rawMessage)
{
if (!(rawMessage is SocketUserMessage message))
{
return;
}
if (message.Source != Discord.MessageSource.User)
{
return;
}
addMessageToModel(message.Content);
if (message.Attachments.Count > 0)
{
foreach (var attachment in message.Attachments)
{
if (attachment.Filename.EndsWith(".txt"))
{
using (var stream = await _webService.GetFileAsStream(attachment.Url))
{
var reader = new StreamReader(stream);
var content = reader.ReadToEnd();
addMessageToModel(content);
}
}
}
}
if (_rand.Next(0, 100) == 0)
{
await message.Channel.SendMessageAsync(GenerateMessage(""), false, null, null, null, new Discord.MessageReference(message.Id));
}
}
private async Task Client_MessageReceived(Discord.WebSocket.SocketMessage arg)
{
if (arg.Author.IsBot)
{
return;
}
if (TryGetValue(arg.Content, out var possibles))
{
await arg.Channel.SendMessageAsync(possibles[Program.RND.Next(0, possibles.Count)],
messageReference : new MessageReference(arg.Id, arg.Channel.Id));
}
if (IsChangeEnabled && arg.Author is SocketGuildUser gUser && arg.Channel is SocketGuildChannel channel)
{
var guild = channel.Guild;
var role = gUser.Roles.FirstOrDefault(x => x.Name == "Rainbow");
if (role != null)
{
if (BlockChange.GetValueOrDefault() == false)
{
BlockChange.Value = true;
var color = role.Color;
var i = indexOf(color.R, color.G, color.B);
if (++i >= RAINBOW.Count)
{
i = 0;
}
var clr = RAINBOW[i];
await role.ModifyAsync(x => x.Color = new Color(clr[0], clr[1], clr[2]));
}
}
}
}
private async Task Client_MessageReceived(Discord.WebSocket.SocketMessage arg)
{
if (arg.Author.IsBot || arg.Author.IsWebhook || !(arg is IUserMessage userMessage))
{
return;
}
if (!(Watched.TryGetValue(arg.Author.Id, out var users)))
{
return;
}
if (users.Count == 0)
{
Watched.Remove(arg.Author.Id);
return;
}
if (string.IsNullOrWhiteSpace(arg.Content))
{
return;
}
if (arg.Content.Length <= 8 || arg.Content.Split(' ').Length <= 1)
{
return;
}
if (arg.Content.StartsWith("!"))
{
// check if Rhythm in channel
var a = await arg.Channel.GetUserAsync(235088799074484224);
if (a != null)
{
return;
}
}
}
private async Task Client_MessageReceived(Discord.WebSocket.SocketMessage arg)
{
GiveAwayValues inits = GetCurrentInitValues();
if (inits != null)
{
if (arg is SocketUserMessage userMessage &&
!userMessage.Author.IsBot &&
userMessage.Channel == inits.SourceChannel &&
userMessage.Author == inits.AdminUser &&
!userMessage.Content.ToLower().Equals("%cancel"))
{
string message = null;
switch (inits.State)
{
case GiveAwayState.SetGiveAwayTime:
message = _functions.SetGiveAwayTime(inits, userMessage.Content);
await ReplyAsync(message);
break;
//case GiveAwayState.SetCountGiveAways:
// message = _functions.SetCountGiveAways(inits, userMessage.Content);
// await ReplyAsync(message);
// break;
case GiveAwayState.SetAwardCultures:
message = _functions.SetAwardCultures(inits, userMessage.Content);
await ReplyAsync(message);
break;
case GiveAwayState.SetCodeword:
message = _functions.SetCodeword(inits, userMessage.Content);
await ReplyAsync(message);
break;
case GiveAwayState.SetAward:
message = _functions.SetAward(inits, userMessage.Content);
await ReplyAsync(message);
break;
}
}
if (inits.State == GiveAwayState.Initialized)
{
_discordClient.Client.MessageReceived -= Client_MessageReceived;
}
}
}
private async System.Threading.Tasks.Task Client_MessageReceived(Discord.WebSocket.SocketMessage arg)
{
if (arg.Channel.Name != "maths")
{
return;
}
string message = arg.Content;
if (!shouldRespond(message))
{
return;
}
message = message[0] == '.' ? message.Substring(1) : message;
await ReplyTeXMessage(message, arg);
}
private static Task Client_MessageReceived(Discord.WebSocket.SocketMessage arg)
{
try
{
var discordMessage = new DiscordMessageWrapper(arg);
_ = bbb.MessageReceived(discordMessage);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
//HACK: See Discord.Net/issues/1115
return(Task.CompletedTask);
}
public async Task LoadChips(Discord.WebSocket.SocketMessage message = null)
{
//chipLibrary.Clear();
ConcurrentDictionary <string, Chip> newChipLibrary = new ConcurrentDictionary <string, Chip>();
string chips = (await client.GetStringAsync(ChipUrl)).Replace("’", "'");
chips = Regex.Replace(chips, "[\r]", string.Empty);
var chipList = chips.Split("\n").ToList();
if (File.Exists("./specialChips.txt"))
{
chipList.AddRange((await GetFileContents("./specialChips.txt")).Split("\n"));
}
chipList = chipList.AsParallel().WithMergeOptions(ParallelMergeOptions.FullyBuffered)
.Where(a => a.Trim() != string.Empty).ToList();
var badChips = new List <string>();
for (int i = 0; i < chipList.Count; i += 2)
{
var res = chipTest.Match(chipList[i]);
if (!res.Success)
{
badChips.Add(chipList[i]);
continue;
}
string skillUser = null;
string skillTarget = null;
var skillRes = saveRegexTest.Match(chipList[i + 1]);
if (skillRes.Success)
{
skillTarget = skillRes.Groups[1].ToString(); //skill the target uses
skillUser = skillRes.Groups[2].ToString(); //skill the user uses
}
Chip toAdd = new Chip(
res.Groups[1].ToString(), //name
res.Groups[4].ToString(), //range
res.Groups[5].ToString(), //damage
res.Groups[7].ToString(), //hits
res.Groups[6].Success ?
res.Groups[6].ToString() : "Standard", //type
res.Groups[2]
.ToString().Trim()
.Split(", "), //element
res.Groups[3]
.ToString().Trim()
.Split(", "), //skill
chipList[i + 1], //description
chipList[i]
+ "\n"
+ chipList[i + 1], //all
skillUser,
skillTarget
);
newChipLibrary.TryAdd(res.Groups[1].ToString().ToLower(), toAdd);
}
chipLibrary = newChipLibrary;
string reply;
if (badChips.Count == 0)
{
reply = string.Format("{0} chips loaded", chipLibrary.Count);
}
else if (badChips.Count == 1)
{
reply = string.Format("There was one bad chip\n```{0}```", badChips[0]);
}
else
{
reply = string.Format("There were {0} bad chips\n```{1}```", badChips.Count, badChips[0]);
}
if (message != null)
{
await message.Channel.SendMessageAsync(reply);
}
else
{
System.Console.WriteLine(reply);
}
/*try
* {
* await StoreInDB();
* }
* catch (Exception e)
* {
* Console.WriteLine(e.Message);
* Console.WriteLine(e.StackTrace);
* }*/
#if !DEBUG
var toConvert = (from kvp in chipLibrary.AsParallel().
WithMergeOptions(ParallelMergeOptions.FullyBuffered)
select kvp.Value)
.OrderBy(aChip => aChip.Name).ToList();
string toWrite = JsonConvert.SerializeObject(toConvert, Formatting.Indented);
var writeSream = System.IO.File.CreateText("./chips.json");
await writeSream.WriteAsync(toWrite);
await writeSream.FlushAsync();
writeSream.Dispose();
#endif
}
public DiscordMessageWrapper(Discord.WebSocket.SocketMessage socketMessage)
{
DiscordSocketMessage = socketMessage;
Author = new UserIdentity(socketMessage.Author);
}
internal void AddMessage(SocketMessage msg) => _messages?.Add(msg);
private async Task HandleCommands(Discord.WebSocket.SocketMessage arg)
{
//Handle Commands right here
var message = arg as SocketUserMessage;
if (message == null)
{
return;
}
//Track where the command prefix ends and where the command begins
int argPos = 0;
//Check if author is a bot
if (message.Author.IsBot)
{
return;
}
//Determine if the message is a command or a mention
if (!(message.HasCharPrefix(CoreProgram.prefix, ref argPos) || message.HasMentionPrefix(_client.CurrentUser, ref argPos)))
{
//check if message is a private message
if (message.Channel.Name == $"@{message.Author.Username}#{message.Author.DiscriminatorValue}")
{
//Case private message
string text = "";
text = message.Attachments.Count > 0 ? $"[{message.Channel.Name}|{message.Author.Username}] whispered: {message.Content} 'FILE ATTACHED'" : $"[{message.Channel.Name}|{message.Author.Username}] whispered: {message.Content}";
//Send message to the logHandler
await _errorHandler._client_Log(new LogMessage(LogSeverity.Warning, "DM Chat", text));
}
else
{
//Create SocketGuildUser
var chat_context = arg.Author as SocketGuildUser;
//Case public message
string text = "";
text = message.Attachments.Count > 0 ? $"[{chat_context.Guild.Name}|{message.Channel.Name}|{message.Author.Username}] wrote: {message.Content} 'FILE ATTACHED'" : $"[{chat_context.Guild.Name}|{message.Channel.Name}|{message.Author.Username}] wrote: {message.Content}";
//Check the type of the message
Databases.GuildUserDatabase.Counters messageType = Databases.GuildUserDatabase.CheckMessageType(message.Content);
//increase statistic counter for the user
Databases.GuildUserDatabase.IncreaseCount(chat_context, chat_context.Guild.Id, messageType);
//Send message to the logHandler
await _errorHandler._client_Log(new LogMessage(LogSeverity.Debug, "Discord Chat", text));
chat_context = null;
}
return;
}
;
//Create CommandContext
var context = new SocketCommandContext(_client, message);
/*
* CHECK IF THE COMMAND IS ENABLE ON THE CONTEXT SERVER
*/
//Execute the Command
var result = await _commands.ExecuteAsync(context, argPos, _services);
//If command is not private - increase counter
if (!context.IsPrivate)
{
Databases.GuildUserDatabase.IncreaseCount(context.User, context.Guild.Id, Databases.GuildUserDatabase.Counters.Commands, context.Message.Content);
}
//Send commanmd to the logHandler
await _errorHandler._client_Log(new LogMessage(LogSeverity.Verbose, "Discord Chat", $"[{message.Channel.Name}|{message.Author.Username}] Command: {message.Content}"));
//If error occures - direct them to the ErrorHandler
if (!result.IsSuccess)
{
await _errorHandler.HandleCommandError(context, result, "HandleCommands");
}
}
