Exemple #1
0
        private void WhoIs(DiscordUserMessage message)
        {
            Helper.WriteCommand(message.CommandText);
            DiscordMember memberToCheck = message.Message.Channel.parent.members.Find(x => x.Username == message.CommandParams[0]);

            if (memberToCheck != null)
            {
                string msg = $"User info for {memberToCheck.Username}\n```\nID: {memberToCheck.ID}\nStatus: {memberToCheck.Status}";
                if (memberToCheck.CurrentGame != null)
                {
                    msg += $"\nCurrent Game: {memberToCheck.CurrentGame}";
                }
                msg += $"\nAvatar: {memberToCheck.GetAvatarURL()}";
                msg += "\n```";
                Concordia.client.SendMessageToChannel(msg, message.Message.Channel);
            }
        }
Exemple #2
0
        private void ParseMessage(DiscordMessageEventArgs message)
        {
            //Clean check
            if (message.message.content.Length <= 1)
            {
                return;
            }
            if (!message.message.content.StartsWith(Concordia.config.CommandPrefix))
            {
                return;
            }

            string[] stuff   = message.message.content.Split(' ');
            string   command = stuff[0].Substring(Concordia.config.CommandPrefix.Length);

            //get command
            var botCommand = CommandManager.GetCommand(command);

            if (botCommand != null)
            {
                DiscordUserMessage dMessage = new DiscordUserMessage();
                dMessage.CommandText = message.message.content;

                string[] commandParams = new string[stuff.Length - 1];

                for (int i = 1; i < stuff.Length; i++)
                {
                    commandParams[i - 1] = stuff[i];
                }

                dMessage.CommandParams = commandParams;
                dMessage.Arguments     = string.Join(" ", commandParams);
                dMessage.Message       = message;
                botCommand.userMessage = dMessage;
                RouteCommand(botCommand);
            }
            else//command is null
            {
                Concordia.client.SendMessageToChannel("Something went horribly wrong in the MessageManager.", message.message.Channel());
            }
        }
        public static async Task PageCommand(BotCommand command)
        {
            DiscordUserMessage message = command.Message as DiscordUserMessage;

            if (message == null)
            {
                return;
            }
            if (message.Discord.LastPageError.Remove(message.DiscordMessage.Channel.Id, out RestUserMessage error))
            {
                await error.DeleteAsync();
            }
            if (command.Bot.DiscordConnection.LastPaginated.TryGetValue(message.DiscordMessage.Channel.Id, out DiscordPaginatedMessage paginated))
            {
                if (command.Arguments.Length > 0)
                {
                    string arg = command.Arguments[0].ToLower();
                    if (arg[0] == 'n') // next
                    {
                        if (paginated.CurrentPage < paginated.PageCount - 1)
                        {
                            paginated.CurrentPage++;
                            await paginated.MessageToEdit.ModifyAsync((x) => x.Embed = paginated.GetPage(paginated.CurrentPage));
                        }
                    }
                    else if (arg[0] == 'p') // previous
                    {
                        if (paginated.CurrentPage > 0)
                        {
                            paginated.CurrentPage--;
                            await paginated.MessageToEdit.ModifyAsync((x) => x.Embed = paginated.GetPage(paginated.CurrentPage));
                        }
                    }
                    else if (arg[0] == 'l') // last
                    {
                        if (paginated.CurrentPage < paginated.PageCount - 1)
                        {
                            paginated.CurrentPage = paginated.PageCount - 1;
                            await paginated.MessageToEdit.ModifyAsync((x) => x.Embed = paginated.GetPage(paginated.CurrentPage));
                        }
                    }
                    else if (int.TryParse(arg, out int num))
                    {
                        if (num > paginated.PageCount)
                        {
                            num = paginated.PageCount;
                        }
                        num--;
                        if (num < 0)
                        {
                            num = 0;
                        }
                        if (paginated.CurrentPage != num)
                        {
                            paginated.CurrentPage = num;
                            await paginated.MessageToEdit.ModifyAsync((x) => x.Embed = paginated.GetPage(paginated.CurrentPage));
                        }
                    }
                    else
                    {
                        message.Discord.LastPageError[message.DiscordMessage.Channel.Id] = await message.DiscordMessage.Channel
                                                                                           .SendMessageAsync($"Invalid command '!{command.Alias} {command.Arguments[0]}' Syntax: !{command.Alias} #/next/prev/last");
                    }
                }
                else
                {
                    message.Discord.LastPageError[message.DiscordMessage.Channel.Id] = await message.DiscordMessage.Channel
                                                                                       .SendMessageAsync($"Invalid command '!{command.Alias}' Syntax: !{command.Alias} #/next/prev/last");
                }
                await message.DiscordMessage.DeleteAsync();
            }
            else
            {
                message.Discord.LastPageError[message.DiscordMessage.Channel.Id] = await message.DiscordMessage.Channel.SendMessageAsync("No recent paginated commands have been executed.");
            }
        }