Example #1
0
        internal async Task Reset()
        {
            Battle = new ColossoBattle();

            if (autoTurn != null)
            {
                autoTurn.Dispose();
            }
            if (resetIfNotActive != null)
            {
                resetIfNotActive.Dispose();
            }

            foreach (var k in Messages.Keys)
            {
                await k.DeleteAsync();
            }

            Messages.Clear();

            if (EnemyMsg != null)
            {
                _ = EnemyMsg.ModifyAsync(c => { c.Content = $"Welcome to {Name} Battle!\n\nReact with <:Fight:536919792813211648> to join the {Name} Battle and press <:Battle:536954571256365096> when you are ready to battle!"; c.Embed = null; });
                await EnemyMsg.RemoveAllReactionsAsync();

                _ = EnemyMsg.AddReactionsAsync(new IEmote[]
                {
                    Emote.Parse("<:Fight:536919792813211648>"),
                    Emote.Parse("<:Battle:536954571256365096>")
                });
            }
            if (StatusMsg != null)
            {
                _         = StatusMsg.DeleteAsync();
                StatusMsg = null;
            }
            winsInARow = 0;
            LureCaps   = 0;
            SetRandomEnemies(ColossoBattle.Team.B);

            autoTurn = new Timer()
            {
                Interval  = 25000,
                AutoReset = false,
                Enabled   = false
            };
            autoTurn.Elapsed += OnTimerTicked;
            resetIfNotActive  = new Timer()
            {
                Interval  = 120000,
                AutoReset = false,
                Enabled   = false
            };
            resetIfNotActive.Elapsed += BattleWasNotStartetInTime;

            Console.WriteLine("Battle was reset.");
        }
Example #2
0
        private async Task WriteEnemies()
        {
            var e     = new EmbedBuilder();
            var tasks = new List <Task>();

            if (Battle.SizeTeamB > 0)
            {
                e.WithThumbnailUrl(Battle.GetTeam(ColossoBattle.Team.B).FirstOrDefault().imgUrl);
            }
            var msg = EnemyMsg;
            var i   = 1;

            foreach (ColossoFighter fighter in Battle.GetTeam(ColossoBattle.Team.B))
            {
                //e.AddField(numberEmotes[i], $"{fighter.name} {fighter.stats.HP}/{fighter.stats.maxHP}", true);
                e.AddField($"{numberEmotes[i]}{fighter.ConditionsToString()}", $"{fighter.name}", true);
                i++;
            }
            if (IsEndless)
            {
                EmbedFooterBuilder footerBuilder = new EmbedFooterBuilder();
                footerBuilder.WithText($"Battle {winsInARow + 1} - {Diff}");
                e.WithFooter(footerBuilder);
            }
            if (!msg.Embeds.FirstOrDefault().ToEmbedBuilder().AllFieldsEqual(e))
            {
                tasks.Add(msg.ModifyAsync(m => m.Embed = e.Build()));
            }

            var validReactions = reactions.Where(r => r.MessageId == EnemyMsg.Id).ToList();

            foreach (var r in validReactions)
            {
                tasks.Add(EnemyMsg.RemoveReactionAsync(r.Emote, r.User.Value));
                reactions.Remove(r);
            }
            await Task.WhenAll(tasks);
        }
Example #3
0
        internal async Task ReactionAdded(Cacheable <IUserMessage, ulong> cache, ISocketMessageChannel channel, SocketReaction reaction)
        {
            try
            {
                if (reaction.User.Value.IsBot)
                {
                    return;
                }
                if (channel.Id != BattleChannel.Id)
                {
                    return;
                }
                if (reaction.Emote.Name == "Fight")
                {
                    _ = AddPlayer(reaction);
                    return;
                }
                else if (reaction.Emote.Name == "Battle")
                {
                    _ = StartBattle();
                    return;
                }

                IUserMessage c = null;
                if (StatusMsg.Id == reaction.MessageId)
                {
                    c = StatusMsg;
                }
                if (EnemyMsg.Id == reaction.MessageId)
                {
                    c = EnemyMsg;
                }
                if (Messages.Keys.Any(k => k.Id == reaction.MessageId))
                {
                    c = Messages.Keys.Where(k => k.Id == reaction.MessageId).First();
                }

                if (c == null)
                {
                    c = (RestUserMessage)await channel.GetMessageAsync(reaction.MessageId);

                    _ = c.RemoveReactionAsync(reaction.Emote, reaction.User.Value);
                    Console.WriteLine("No matching Message for User found.");
                    return;
                }

                if (!Battle.isActive)
                {
                    _ = c.RemoveReactionAsync(reaction.Emote, reaction.User.Value);
                    Console.WriteLine("Battle not active.");
                    return;
                }

                if (Battle.turnActive)
                {
                    _ = c.RemoveReactionAsync(reaction.Emote, reaction.User.Value);
                    Console.WriteLine("Not so fast");
                    return;
                }

                if (reaction.Emote.Name == "🔄")
                {
                    await c.RemoveReactionAsync(reaction.Emote, reaction.User.Value);

                    autoTurn.Stop();
                    Task.WaitAll(Messages.Select(m => m.Key.RemoveAllReactionsAsync()).Append(EnemyMsg.RemoveAllReactionsAsync()).ToArray());

                    _ = WriteBattleInit();
                    autoTurn.Start();
                    return;
                }

                if (reaction.Emote.Name == "⏸")
                {
                    autoTurn.Stop();
                    return;
                }

                if (reaction.Emote.Name == "▶")
                {
                    autoTurn.Start();
                    return;
                }

                if (reaction.Emote.Name == "⏩")
                {
                    _ = ProcessTurn(true);
                    return;
                }

                var curPlayer = Messages.Values.Where(p => p.name == ((SocketGuildUser)reaction.User.Value).DisplayName()).FirstOrDefault();
                var correctID = Messages.Keys.Where(key => Messages[key].name == curPlayer.name).First().Id;

                if (!numberEmotes.Contains(reaction.Emote.Name))
                {
                    if (reaction.MessageId != EnemyMsg.Id && reaction.MessageId != correctID)
                    {
                        _ = c.RemoveReactionAsync(reaction.Emote, reaction.User.Value);
                        Console.WriteLine("Didn't click on own message.");
                        return;
                    }
                }

                if (isProcessing)
                {
                    _ = c.RemoveReactionAsync(reaction.Emote, reaction.User.Value);
                    Console.WriteLine("Still processing.");
                    return;
                }
                if (!curPlayer.Select(reaction.Emote.Name))
                {
                    _ = c.RemoveReactionAsync(reaction.Emote, reaction.User.Value);
                    Console.WriteLine("Couldn't select that move.");
                    return;
                }
                reactions.Add(reaction);

                _ = ProcessTurn(forced: false);
            }
            catch (Exception e)
            {
                Console.WriteLine("Colosso Turn Processing Error: " + e.Message);
                File.WriteAllText($"Logs/Crashes/Error_{DateTime.Now.Date}.log", e.Message);
            }
        }