perefouras/modules/fouras.py

from .base import BaseModule, ENCODING
import random
import re
import time
import json
from unidecode import unidecode


class FourasModule(BaseModule):
    def load(self):
        with open("riddles.txt", "r", encoding=ENCODING) as r_file:
            self._client.riddles = r_file.read().split("\n\n")
        with open("answers.txt", "r", encoding=ENCODING) as a_file:
            self._client.answers = [line.strip() for line in a_file.readlines()]
        print(f"Loaded {len(self._client.riddles)} riddles")

    def new_riddle(self, channel, index):
        current_riddle = dict(
            index=index,
            nbClues=-1,
            riddle=self._client.riddles[index].strip(),
            answer=self._client.answers[index],
        )
        self._client.ongoing_riddles[channel] = current_riddle
        return self.format_message(current_riddle)

    def finish_riddle(self, channel):
        del self._client.ongoing_riddles[channel]

    def clue_string(self, answer, nbClues):
        finalString = "_"
        for i in range(len(answer) - 1):
            finalString += " _"
        random.seed(hash(answer))
        nbRevealed = 0
        for i in range(nbClues):
            id = random.randint(0, len(answer) - 1)
            while finalString[id * 2] != "_":
                id = random.randint(0, len(answer) - 1)

            nbRevealed += 1
            finalString = finalString[: id * 2] + answer[id] + finalString[id * 2 + 1 :]

            if nbRevealed == len(answer):
                return finalString
        return finalString

    def format_message(self, current_riddle):
        nbClues = current_riddle["nbClues"]
        answer = current_riddle["answer"]

        formatted_riddle = "> " + current_riddle["riddle"].replace("\n", "\n> ")
        formatted_riddle = formatted_riddle.replace("\r", "")

        clue = ""
        if nbClues > -1:
            if nbClues >= len(answer):
                clue = clue + "\nNon trouvée, la solution était : `{0}`".format(answer)
            else:
                clue = clue + "\nIndice : `{0}`".format(self.clue_string(answer, nbClues))

        if "solver" in current_riddle:
            clue = clue + "\n{0} a trouvé la solution, qui était : `{1}`".format(
                current_riddle["solver"].mention, answer
            )

        if clue:
            return "Énigme {0}:\n{1}\n{2}".format(current_riddle["index"] + 1, formatted_riddle, clue)
        else:
            return "Énigme {0}:\n{1}".format(current_riddle["index"] + 1, formatted_riddle)

    async def handle_message(self, message):
        message_content = message.content.lower()

        # command fouras
        fouras_match = re.match(r"^fouras\s+(\d+)$", message_content)
        if fouras_match:
            index = int(fouras_match.group(1)) - 1
            if index >= 0 and index < len(self._client.riddles):
                if random.random() <= 0.03:
                    await message.channel.send("Non")
                else:
                    await message.channel.send(self.new_riddle(message.channel, index))
            else:
                await message.channel.send(
                    f"Numéro d'énigme invalide, merci de saisir un numéro entre 1 et {len(self._client.riddles)}"
                )
            return
        if message_content == "fouras":
            if random.random() <= 0.03:
                await message.channel.send("Non")
            elif len(self._client.riddles) > 0:
                index = random.randint(0, len(self._client.riddles) - 1)
                await message.channel.send(self.new_riddle(message.channel, index))
            return

        # command reload
        if message_content == "reload_riddles":
            self.load()
            await message.channel.send("Loaded {0} riddles".format(len(self._client.riddles)))
            return

        if message_content == "about fouras":
            author_user = await self.client.fetch_user(151626081458192384)
            await message.channel.send(
                f"Ce bot a été développé par {author_user.mention}\nCode Source : https://gitlab.epicsparrow.com/Anselme/perefouras\nAjouter ce bot à votre serveur : https://discord.com/api/oauth2/authorize?client_id=1110208055171367014&permissions=274877975552&scope=bot"
            )
            return

        if message_content == "debug fouras":
            dump = {}
            cooldowns = {}
            for key, value in self.client.cooldown.items():
                channel_name = await self.get_channel_name(key)
                cooldowns[channel_name] = value - time.time()
            dump["poil_au_cooldown"] = cooldowns
            for key, value in self._client.ongoing_riddles.items():
                dump_channel = value
                dump_channel.pop("message", None)
                dump_channel["answer"] = "||{0}||".format(dump_channel["answer"])
                channel_name = await self.get_channel_name(key)
                dump[channel_name] = dump_channel
            await message.author.send(json.dumps(dump, ensure_ascii=False, indent=4))
            return

        # if current channel has ongoing riddle
        if message.channel in self._client.ongoing_riddles:
            current_riddle = self._client.ongoing_riddles[message.channel]

            if "message" in current_riddle:
                answer = current_riddle["answer"]
                if unidecode(answer.lower()) in unidecode(message_content):
                    current_riddle["solver"] = message.author

                    await message.channel.send(f"Bravo {message.author.mention} ! La réponse était bien `{answer}`.")
                    await current_riddle["message"].edit(content=self.format_message(current_riddle))
                    self.finish_riddle(message.channel)
                    return

                if message_content == "repete" or message_content == "répète" or message_content == "repeat":
                    current_riddle.pop("message")
                    await message.channel.send(self.format_message(current_riddle))
                    return

                # Commande /clue : révèle une lettre au hasard de la réponse attendue
                if (
                    message_content == "indice"
                    or message_content == "aide"
                    or message_content == "help"
                    or message_content == "clue"
                ):
                    nbClues = current_riddle["nbClues"] + 1
                    current_riddle["nbClues"] = nbClues
                    if nbClues >= len(answer):
                        reply = "Perdu ! La réponse était : `{0}`".format(answer)
                        await message.channel.send(reply)
                    # else:
                    #    reply = "Indice : `{0}`".format(clue_string(answer, nbClues))
                    await current_riddle["message"].edit(content=self.format_message(current_riddle))
                    if nbClues >= len(answer):
                        self.finish_riddle(message.channel)
                    return