C# Dividir mensagem do bot

[diogorocha18]

Bom dia, 

 

Eu fiz um bot para o discord para me avisar de uma determinada coisa de um jogo que jogo há alguns anos. 

 

No entanto, agora que já se passou algum tempo e "cresci in game", o bot envia mais informação, no entanto o discord tem um limite de 2000 caracteres e precisava que dividir-se a mensagem em 2,3 ou 4 vezes, as vezes necessárias para que não desse erro e não enviasse a informação por causa disso. 

 

Alguém disponível para me ajudar? 

 

Cumprimentos 

[Lucca Rodrigues]

5 horas atrás, diogorocha18 disse:

Alguém disponível para me ajudar? 

O fórum é público, se precisa de ajuda com seu código eu recomendo que poste ele.

Use o botão Code

[diogorocha18]

7 horas atrás, Lucca Rodrigues disse:

O fórum é público, se precisa de ajuda com seu código eu recomendo que poste ele.

Use o botão Code

 

peço desculpas, pensava que tinha colocado, o ficheiro responsavel por isso encontra-se aqui:

 

using Discord;
using Discord.WebSocket;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using TW_Discord_Bot.Core;
using TW_Discord_Bot.Persistence.Domain;
using TW_Discord_Bot.Persistence.Repositories.ChannelOutput;
using TW_Discord_Bot.Persistence.Repositories.Configuration;
using TW_Discord_Bot.Persistence.Repositories.IncomingAttacks;
using TW_Discord_Bot.Persistence.Repositories.IngameName;
using TW_Discord_Bot.Services;

namespace TW_Discord_Bot.Jobs
{
    public class IncomingAttacksJob : BackgroundService
    {
        private readonly IChannelOutputRepository _channelOutputRepository;
        private readonly IConfigurationRepository _configurationRepository;
        private readonly IIncomingAttacksRepository _incomingAttacksRepository;
        private readonly IIngameNameRepository _ingameNameRepository;

        private readonly DiscordSocketClient _client;
        private readonly ILogger _logger;
        private const long GuildId = 806622903251632138;
        private const long AdminId = 379999320877039617;

        public IncomingAttacksJob(
            DiscordSocketClient client,
            ILogger<IncomingAttacksJob> logger,
            IChannelOutputRepository channelOutputRepository,
            IConfigurationRepository configurationRepository,
            IIncomingAttacksRepository incomingAttacksRepository,
            IIngameNameRepository ingameNameRepository)
        {
            _channelOutputRepository = channelOutputRepository ?? throw new ArgumentNullException(nameof(channelOutputRepository));
            _configurationRepository = configurationRepository ?? throw new ArgumentNullException(nameof(configurationRepository));
            _incomingAttacksRepository = incomingAttacksRepository ?? throw new ArgumentNullException(nameof(incomingAttacksRepository));
            _ingameNameRepository = ingameNameRepository ?? throw new ArgumentNullException(nameof(ingameNameRepository));

            _client = client ?? throw new ArgumentNullException(nameof(client));
            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        }

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            await Task.Delay(3000);
            while (!stoppingToken.IsCancellationRequested)
            {
                try
                {
                    var configurations = await _configurationRepository.FindDefaultAsync(x => x.ServerId == GuildId);

                    if (configurations == null)
                    {
                        _logger.LogError("Configurar SID / User-Agent / Url para ataques a chegar!");
                    }

                    if (configurations.AccountSID == "")
                    {
                        _logger.LogError("Configurar SID a chegar!");
                    }

                    var tribalWarsClient = new TribalWarsClientService(configurations.AccountSID, configurations.AccountUserAgent);

                    var timer = new Stopwatch();
                    timer.Start();

                    var incomingAttacks = await tribalWarsClient.GetIncomingAttacks(configurations.WorldUrl);

                    var guild = _client.GetGuild(GuildId);
                    var messageChannel = guild.GetChannel(configurations.AttackChannelId.Value) as IMessageChannel;


                    foreach (var incomingAttack in incomingAttacks)
                    {
                        var oldIncomingAttacksEntity = await _incomingAttacksRepository.FindAsync(x => x.PlayerName == incomingAttack.Name);
                        if (oldIncomingAttacksEntity == null) continue;

                        var oldIncomingAttacks = oldIncomingAttacksEntity.ToList();

                        if (incomingAttack.TotalNrAttacks > oldIncomingAttacks.Sum(x => x.NrAttacks))
                        {
                            var addNewAttacks = new List<IncomingAttacks>();
                            var updateAttacks = new List<IncomingAttacks>();

                            var msg = $"> **{incomingAttack.Name}**\n";
                            msg += $"> _Total de ataques a chegar: **{incomingAttack.TotalNrAttacks}**_\n\n";

                            //var index = 0;

                            foreach (var village in incomingAttack.Villages)
                            {
                                
                                if (village.IncomingAttacks > 0)
                                {
                                    var villageUnderAttack = oldIncomingAttacks.Any(x => x.VillageName == village.Name);

                                        if (villageUnderAttack)
                                        {
                                            var underAttackOldCount = oldIncomingAttacks.Where(x => x.VillageName == village.Name).Sum(x => x.NrAttacks);


                                            if (village.IncomingAttacks > underAttackOldCount)
                                            {
                                                var newAttacks = village.IncomingAttacks - underAttackOldCount;
                                                msg += $"> _ {village.Name}:_ {village.IncomingAttacks} **[+{newAttacks} NEW]** \n";
                                            }
                                            else
                                            {
                                                //msg += $"{village.Name}: {village.IncomingAttacks}\n";

                                            }



                                            updateAttacks.Add(new IncomingAttacks
                                            {
                                                Id = oldIncomingAttacks.FirstOrDefault(x => x.VillageName == village.Name)?.Id,
                                                LastAttackInformation = DateTime.Now,
                                                NrAttacks = village.IncomingAttacks,
                                                PlayerName = incomingAttack.Name,
                                                VillageName = village.Name,
                                                ServerId = (long)guild.Id,
                                                ServerName = guild.Name
                                            });
                                        }
                                        else
                                        {
                                            msg += $"> _ {village.Name}:_ {village.IncomingAttacks} **[+{village.IncomingAttacks} NEW]** \n";
                                            addNewAttacks.Add(new IncomingAttacks
                                            {
                                                LastAttackInformation = DateTime.Now,
                                                NrAttacks = village.IncomingAttacks,
                                                PlayerName = incomingAttack.Name,
                                                VillageName = village.Name,
                                                ServerId = (long)guild.Id,
                                                ServerName = guild.Name
                                            });
                                        }

                                }
                            }

                            var totalAtaques = addNewAttacks.Sum(x => x.NrAttacks) + updateAttacks.Sum(x => x.NrAttacks);
                            if (addNewAttacks.Count > 0)
                            {
                                await _incomingAttacksRepository.AddAsync(addNewAttacks);
                            }

                            if (updateAttacks.Count > 0)
                            {
                                await _incomingAttacksRepository.UpdateAsync(updateAttacks);
                            }

                            Console.WriteLine(msg);

                      

                            await messageChannel.SendMessageAsync(text: msg);

                            var checkForPing = await _ingameNameRepository.FindDefaultAsync(x => x.GameName == incomingAttack.Name);

                            if (checkForPing != null)
                            {
                                var user = guild.GetUser(checkForPing.DiscordId);

                                await messageChannel.SendMessageAsync(user.Mention);
                            }

                        }
                        else if (incomingAttack.TotalNrAttacks == 0)
                        {
                            await _incomingAttacksRepository.DeleteAsync(x => x.PlayerName == incomingAttack.Name);
                        }
                    }

                    Random rnd = new Random();
                    var randomMinutes = rnd.Next(4, 7);
                    timer.Stop();

                    TimeSpan timeTaken = timer.Elapsed;
                    string timeElapsed = "Demorou " + timeTaken.ToString(@"m\:ss\:fff");
                    _logger.LogInformation($"{timeElapsed} para buscar informação sobre ataques a chegar. Proximo job corre daqui a {randomMinutes} minutos.");

                    await Task.Delay(TimeSpan.FromMinutes(randomMinutes));
                }
                catch (SessionException ex)
                {
                    var channelOutput = await _channelOutputRepository.FindDefaultAsync(x => x.ServerId == GuildId);

                    var guild = _client.GetGuild(GuildId);

                    var member = guild.GetUser(AdminId);

                    var messageChannel = guild.GetChannel((ulong)channelOutput.ChannelId.Value) as IMessageChannel;
                    await messageChannel.SendMessageAsync($"{member.Mention} -> [{ex.ErrorCode}] {ex.LogMessage}");

                    _logger.LogError($"[{ex.ErrorCode}] {ex.LogMessage}");
                    await Task.Delay(TimeSpan.FromMinutes(15));
                }
                catch (Exception ex)
                {
                    _logger.LogError($"Unexpected error occured. {ex.Message} | {ex.StackTrace}");
                    await Task.Delay(TimeSpan.FromMinutes(15));
                }
            }

        }

        public override async Task StartAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation("Started Incoming attacks job.");
            new Thread(async () => await ExecuteAsync(cancellationToken)).Start();

            await Task.CompletedTask;
        }

        public override Task StopAsync(CancellationToken cancellationToken)
        {
            //log stop
            return Task.CompletedTask;
        }

       
    }
}

 

[diogorocha18]

alguém me consegue ajudar?