import asyncio from json import JSONDecodeError, loads from random import choice from discord import Embed from discord.ext import commands from bot.bot import Bot from bot.constants import Colours, NEGATIVE_REPLIES, POSITIVE_REPLIES, Roles from bot.utils.pagination import LinePaginator from ._game import AllQuestionsVisitedError, TriviaNightGame from ._questions import QuestionView from ._scoreboard import Scoreboard # The ID you see below are the Events Lead role ID and the Event Runner Role ID TRIVIA_NIGHT_ROLES = (Roles.admins, 778361735739998228, 940911658799333408) class TriviaNightCog(commands.Cog): """Cog for the Python Trivia Night event.""" def __init__(self, bot: Bot): self.bot = bot self.game: TriviaNightGame | None = None self.scoreboard: Scoreboard | None = None self.question_closed: asyncio.Event = None @commands.group(aliases=["tn"], invoke_without_command=True) async def trivianight(self, ctx: commands.Context) -> None: """ The command group for the Python Discord Trivia Night. If invoked without a subcommand (i.e. simply .trivianight), it will explain what the Trivia Night event is. """ cog_description = Embed( title="What is .trivianight?", description=( "This 'cog' is for the Python Discord's TriviaNight (date tentative)! Compete against other" " players in a trivia about Python!" ), color=Colours.soft_green ) await ctx.send(embed=cog_description) @trivianight.command() @commands.has_any_role(*TRIVIA_NIGHT_ROLES) async def load(self, ctx: commands.Context, *, to_load: str | None) -> None: """ Loads a JSON file from the provided attachment or argument. The JSON provided is formatted where it is a list of dictionaries, each dictionary containing the keys below: - number: int (represents the current question #) - description: str (represents the question itself) - answers: list[str] (represents the different answers possible, must be a length of 4) - correct: str (represents the correct answer in terms of what the correct answer is in `answers` - time: Optional[int] (represents the timer for the question and how long it should run, default is 10) - points: Optional[int] (represents how many points are awarded for each question, default is 10) The load command accepts three different ways of loading in a JSON: - an attachment of the JSON file - a message link to the attachment/JSON - reading the JSON itself via a codeblock or plain text """ if self.game is not None: await ctx.send(embed=Embed( title=choice(NEGATIVE_REPLIES), description="There is already a trivia night running!", color=Colours.soft_red )) return if ctx.message.attachments: json_text = (await ctx.message.attachments[0].read()).decode("utf8") elif not to_load: raise commands.BadArgument("You didn't attach an attachment nor link a message!") elif ( to_load.startswith(("https://discord.com/channels", "https://discordapp.com/channels")) ): channel_id, message_id = to_load.split("/")[-2:] channel = await ctx.guild.fetch_channel(int(channel_id)) message = await channel.fetch_message(int(message_id)) if message.attachments: json_text = (await message.attachments[0].read()).decode("utf8") else: json_text = message.content.replace("```", "").replace("json", "").replace("\n", "") else: json_text = to_load.replace("```", "").replace("json", "").replace("\n", "") try: serialized_json = loads(json_text) except JSONDecodeError as error: raise commands.BadArgument(f"Looks like something went wrong:\n{error!s}") self.game = TriviaNightGame(serialized_json) self.question_closed = asyncio.Event() success_embed = Embed( title=choice(POSITIVE_REPLIES), description="The JSON was loaded successfully!", color=Colours.soft_green ) self.scoreboard = Scoreboard(self.bot) await ctx.send(embed=success_embed) @trivianight.command(aliases=("next",)) @commands.has_any_role(*TRIVIA_NIGHT_ROLES) async def question(self, ctx: commands.Context, question_number: str | None = None) -> None: """ Gets a random question from the unanswered question list and lets the user(s) choose the answer. This command will continuously count down until the time limit of the question is exhausted. However, if `.trivianight stop` is invoked, the counting down is interrupted to show the final results. """ if self.game is None: await ctx.send(embed=Embed( title=choice(NEGATIVE_REPLIES), description="There is no trivia night running!", color=Colours.soft_red )) return if self.game.current_question is not None: error_embed = Embed( title=choice(NEGATIVE_REPLIES), description="There is already an ongoing question!", color=Colours.soft_red ) await ctx.send(embed=error_embed) return try: next_question = self.game.next_question(question_number) except AllQuestionsVisitedError: error_embed = Embed( title=choice(NEGATIVE_REPLIES), description="All of the questions have been used.", color=Colours.soft_red ) await ctx.send(embed=error_embed) return await ctx.send("Next question in 3 seconds! Get ready...") await asyncio.sleep(3) question_view = QuestionView(next_question) question_embed = question_view.create_embed() next_question.start() message = await ctx.send(embed=question_embed, view=question_view) # Exponentially sleep less and less until the time limit is reached percentage = 1 while True: percentage *= 0.5 duration = next_question.time * percentage await asyncio.wait([self.question_closed.wait()], timeout=duration) if self.question_closed.is_set(): await ctx.send(embed=question_view.end_question(self.scoreboard)) await message.edit(embed=question_embed, view=None) self.game.end_question() self.question_closed.clear() return if int(duration) > 1: # It is quite ugly to display decimals, the delay for requests to reach Discord # cause sub-second accuracy to be quite pointless. await ctx.send(f"{int(duration)}s remaining...") else: # Since each time we divide the percentage by 2 and sleep one half of the halves (then sleep a # half, of that half) we must sleep both halves at the end. await asyncio.wait([self.question_closed.wait()], timeout=duration) if self.question_closed.is_set(): await ctx.send(embed=question_view.end_question(self.scoreboard)) await message.edit(embed=question_embed, view=None) self.game.end_question() self.question_closed.clear() return break await ctx.send(embed=question_view.end_question(self.scoreboard)) await message.edit(embed=question_embed, view=None) self.game.end_question() @trivianight.command() @commands.has_any_role(*TRIVIA_NIGHT_ROLES) async def list(self, ctx: commands.Context) -> None: """ Display all the questions left in the question bank. Questions are displayed in the following format: Q(number): Question description | :white_check_mark: if the question was used otherwise :x:. """ if self.game is None: await ctx.send(embed=Embed( title=choice(NEGATIVE_REPLIES), description="There is no trivia night running!", color=Colours.soft_red )) return question_list = self.game.list_questions() list_embed = Embed(title="All Trivia Night Questions") if len(question_list) == 1: list_embed.description = question_list[0] await ctx.send(embed=list_embed) else: await LinePaginator.paginate( question_list, ctx, list_embed ) @trivianight.command() @commands.has_any_role(*TRIVIA_NIGHT_ROLES) async def stop(self, ctx: commands.Context) -> None: """ End the ongoing question to show the correct question. This command should be used if the question should be ended early or if the time limit fails """ if self.game is None: await ctx.send(embed=Embed( title=choice(NEGATIVE_REPLIES), description="There is no trivia night running!", color=Colours.soft_red )) return if self.game.current_question is None: error_embed = Embed( title=choice(NEGATIVE_REPLIES), description="There is no ongoing question!", color=Colours.soft_red ) await ctx.send(embed=error_embed) return self.question_closed.set() @trivianight.command() @commands.has_any_role(*TRIVIA_NIGHT_ROLES) async def end(self, ctx: commands.Context) -> None: """ Displays the scoreboard view. The scoreboard view consists of the two scoreboards with the 30 players who got the highest points and the 30 players who had the fastest average response time to a question where they got the question right. The scoreboard view also has a button where the user can see their own rank, points and average speed if they didn't make it onto the leaderboard. """ if self.game is None: await ctx.send(embed=Embed( title=choice(NEGATIVE_REPLIES), description="There is no trivia night running!", color=Colours.soft_red )) return if self.game.current_question is not None: error_embed = Embed( title=choice(NEGATIVE_REPLIES), description="You can't end the event while a question is ongoing!", color=Colours.soft_red ) await ctx.send(embed=error_embed) return scoreboard_embed, scoreboard_view = await self.scoreboard.display() await ctx.send(embed=scoreboard_embed, view=scoreboard_view) @trivianight.command() @commands.has_any_role(*TRIVIA_NIGHT_ROLES) async def scoreboard(self, ctx: commands.Context) -> None: """ Displays the scoreboard. The scoreboard consists of the two scoreboards with the 30 players who got the highest points and the 30 players who had the fastest average response time to a question where they got the question right. """ if self.game is None: await ctx.send(embed=Embed( title=choice(NEGATIVE_REPLIES), description="There is no trivia night running!", color=Colours.soft_red )) return if self.game.current_question is not None: error_embed = Embed( title=choice(NEGATIVE_REPLIES), description="You can't end the event while a question is ongoing!", color=Colours.soft_red ) await ctx.send(embed=error_embed) return scoreboard_embed, speed_scoreboard = await self.scoreboard.display(speed_leaderboard=True) await ctx.send(embeds=(scoreboard_embed, speed_scoreboard)) @trivianight.command() @commands.has_any_role(*TRIVIA_NIGHT_ROLES) async def end_game(self, ctx: commands.Context) -> None: """Ends the ongoing game.""" self.game = None await ctx.send(embed=Embed( title=choice(POSITIVE_REPLIES), description="The game has been stopped.", color=Colours.soft_green )) async def setup(bot: Bot) -> None: """Load the TriviaNight cog.""" await bot.add_cog(TriviaNightCog(bot))