Esempio n. 1
0
        public async Task HalveAsync()
        {
            if (!ChannelCheck.IsKnockoutChannel(Context))
            {
                return;
            }

            if (Context.IsPrivate)
            {
                await Context.Channel.SendMessageAsync("Please use this command in the knockout channel!");

                return;
            }

            var knockouts = new KnockOutHandler(Context.Channel.Id, Factory.GetDatabase());

            if (Context.User.Id != knockouts.KnockoutCreatorUlong)
            {
                await Context.Channel.SendMessageAsync(":x: You are no the creator of this knockout!");
            }

            switch (knockouts.KnockoutStatus)
            {
            case 1:
                await Context.Channel.SendMessageAsync(":x: No Active Knockout In Progress");

                return;

            case 2:
                break;

            case 3:
                await Context.Channel.SendMessageAsync(":x: No Active Knockout In Progress");

                return;

            case 4:
                await Context.Channel.SendMessageAsync(":x: No Active Knockout In Progress");

                return;

            default:
                await Context.Channel.SendMessageAsync(":x: Right. This shouldn't have happened. Someone call RedFlint.");

                return;
            }

            await Context.Channel.SendMessageAsync("https://i.imgur.com/5NFHKiJ.gif");

            await Context.Channel.SendMessageAsync("**When I'm done, half of the votes will still exist. Perfectly balanced, as all things should be.**");

            knockouts.HalveScores();
            await BotEmbeds.ShowKnockout(Context, knockouts);
        }
Esempio n. 2
0
        public async Task PreviewKnockoutAsync()
        {
            if (!StateChecker.IsPrivateMessage(Context))
            {
                return;
            }

            var channelId = KnockOutHandler.ChannelForUser(Context.User.Id, Factory.GetDatabase());

            if (channelId == 0)
            {
                await Context.Channel.SendMessageAsync(":x: You are not making a knockout at the moment!");

                return;
            }

            var knockouts = new KnockOutHandler(channelId, Factory.GetDatabase());

            if (knockouts.KnockoutCreatorUlong != Context.User.Id)
            {
                await Context.Channel.SendMessageAsync(":x: You are not making a knockout at the moment!");

                return;
            }

            switch (knockouts.KnockoutStatus)
            {
            case 1:
                await Context.Channel.SendMessageAsync(":x: No Knockout is being created at the moment!");

                return;

            case 2:
                await Context.Channel.SendMessageAsync(":x: This knockout has already started! Preview in main channel.");

                return;

            case 3:
                await Context.Channel.SendMessageAsync(":x: This knockout is finished, see the results in the main channel.");

                return;

            case 4:
                break;

            default:
                await Context.Channel.SendMessageAsync(":x: Right. This shouldn't have happened. Someone call RedFlint.");

                return;
            }

            await BotEmbeds.ShowKnockout(Context, knockouts);
        }
Esempio n. 3
0
        public async Task EmbedKnockoutAsync()
        {
            if (!StateChecker.IsKnockoutChannel(Context) || StateChecker.IsPrivateMessage(Context))
            {
                return;
            }

            var knockouts = new KnockOutHandler(Context.Channel.Id, Factory.GetDatabase());

            switch (knockouts.KnockoutStatus)
            {
            case 1:
                await Context.Channel.SendMessageAsync(":x: No Knockout has been created or is being created. Go for it! Type !createknockout to begin.");

                return;

            case 2:
                await BotEmbeds.ShowKnockout(Context, knockouts);

                return;

            case 3:
                await BotEmbeds.KnockoutIsOver(Context, knockouts);

                break;

            case 4:
                var userId   = knockouts.KnockoutCreatorUlong;
                var username = Context.Client.GetUser(userId).Username;
                await Context.Channel.SendMessageAsync($"This Knockout is currently under construction by **{username}**! Feel free to advise!");

                await BotEmbeds.ShowKnockout(Context, knockouts);

                return;

            default:
                await Context.Channel.SendMessageAsync(":x: Right. This shouldn't have happened. Someone call RedFlint.");

                return;
            }
        }
Esempio n. 4
0
        public async Task BeginKnockoutAsync()
        {
            if (!StateChecker.IsPrivateMessage(Context))
            {
                return;
            }

            var channelId = KnockOutHandler.ChannelForUser(Context.User.Id, Factory.GetDatabase());

            if (channelId == 0)
            {
                await Context.Channel.SendMessageAsync(":x: You are not making a knockout at the moment!");

                return;
            }

            var knockouts = new KnockOutHandler(channelId, Factory.GetDatabase());

            if (knockouts.KnockoutCreatorUlong != Context.User.Id)
            {
                await Context.Channel.SendMessageAsync(":x: You are not making a knockout at the moment!");

                return;
            }

            switch (knockouts.KnockoutStatus)
            {
            case 1:
                await Context.Channel.SendMessageAsync(":x: No Knockout is being created at the moment!");

                return;

            case 2:
                await Context.Channel.SendMessageAsync(":x: This knockout has already started! No more changes!");

                return;

            case 3:
                await Context.Channel.SendMessageAsync(":x: This knockout is finished, please feel free to create a new one!");

                return;

            case 4:
                break;

            default:
                await Context.Channel.SendMessageAsync(":x: Right. This shouldn't have happened. Someone call RedFlint.");

                return;
            }

            if (knockouts.ContendersCount < 4)
            {
                await Context.Channel.SendMessageAsync(":x: Knockouts are over when it reaches the Top 3. Please add more Contenders.");

                return;
            }

            if (knockouts.KnockoutTitle == "" || knockouts.KnockoutTitle == "No Knockout In Progress" || knockouts.KnockoutTitle == "Knockout Under Construction")
            {
                await Context.Channel.SendMessageAsync(":x: Please Name your Knockout");

                return;
            }

            knockouts.SetKnockoutToActive();

            await Context.Channel.SendMessageAsync("You're done! Please check in main channel for the knockout!");

            var chnl = Context.Client.GetChannel(knockouts.KnockoutChannelUlong) as Discord.IMessageChannel;
            await chnl.SendMessageAsync("A New Knockout Has Been Created!");

            await BotEmbeds.ShowKnockout(Context, chnl, knockouts);
        }
Esempio n. 5
0
        public async Task PlayAsync([Remainder] string input = "")
        {
            if (!StateChecker.IsKnockoutChannel(Context) || StateChecker.IsPrivateMessage(Context))
            {
                return;
            }

            if (input == "")
            {
                await Context.Channel.SendMessageAsync(":x: Please enter your options in this format: *!vote choice to add/choice to delete*");

                return;
            }

            if (!input.Contains("/") || input.Count(c => c == '/') > 1)
            {
                await Context.Channel.SendMessageAsync(":x: Please enter your options in this format: *!vote choice to add/choice to delete*");

                return;
            }

            var choices = input.Split('/');

            var choiceToAdd = choices.First();
            var choiceToSub = choices.Last();

            var knockouts = new KnockOutHandler(Context.Channel.Id, Factory.GetDatabase());

            switch (knockouts.KnockoutStatus)
            {
            case 1:
                await Context.Channel.SendMessageAsync(":x: No Knockout ongoing. Feel free to start a new one!");

                return;

            case 2:
                break;

            case 3:
                await Context.Channel.SendMessageAsync(":x: This knockout is finished. Feel free to start a new one!");

                return;

            case 4:
                await Context.Channel.SendMessageAsync(":x: This knockout is still under construction! Patience!");

                return;

            default:
                await Context.Channel.SendMessageAsync(":x: Right. This shouldn't have happened. Someone call RedFlint.");

                return;
            }

            if (knockouts.PlayerWentLastTime(Context.User.Id))
            {
                await Context.Channel.SendMessageAsync(":x: You just went! Give a few other people a chance!");

                return;
            }

            if (knockouts.TurnsLeftForPlayer(Context.User.Id) <= 0)
            {
                await Context.Channel.SendMessageAsync(":x: You are out of turns, please wait until the turns are reset");

                return;
            }

            var original = choiceToAdd;

            choiceToAdd = knockouts.FindNearestMatch(choiceToAdd);
            if (choiceToAdd == "ERROR")
            {
                await Context.Channel.SendMessageAsync($":x: I'm sorry, I could not find a close match for **{original}**, please try again");

                return;
            }

            original    = choiceToSub;
            choiceToSub = knockouts.FindNearestMatch(choiceToSub);
            if (choiceToSub == "ERROR")
            {
                await Context.Channel.SendMessageAsync($":x: I'm sorry, I could not find a close match for **{original}**, please try again");

                return;
            }

            if (choiceToAdd == choiceToSub)
            {
                await Context.Channel.SendMessageAsync(":x: Choices are the same, try again.");

                return;
            }

            knockouts.ApplyVoteChanges(choiceToAdd, choiceToSub, Context.User.Id);

            if (knockouts.LivingContendersCount <= 3)
            {
                knockouts.EndKnockout();

                await BotEmbeds.KnockoutIsOver(Context, knockouts);
            }
            else
            {
                var userName  = Context.User.Username;
                var avatarUrl = Context.User.GetAvatarUrl();

                await Context.Channel.SendMessageAsync("", false, BotEmbeds.PlayerVotingReportEmbed(userName, avatarUrl, choiceToAdd, choiceToSub));

                var recentKiller = knockouts.PlayerHasJustKilled();

                if (recentKiller != 0)
                {
                    var killer = Context.Client.GetUser(recentKiller);

                    if (killer != null)
                    {
                        await killer.SendMessageAsync("You have killed a contender, type !epitaph _<message>_ in the main channel to leave a mark on their grave!");

                        await killer.SendMessageAsync("(please note, if you eliminate another contender, you will lose the opportunity to engrave an epitaph for this one)");
                    }

                    knockouts.GetContendersFromDb();
                }

                await BotEmbeds.ShowKnockout(Context, knockouts);
            }
        }