Hello everyone,

I’m working on a multiplayer Discord bot for a quiz game, and I’m facing an issue with the synchronization of the countdown timer and the answer processing. The problem occurs when a user submits an answer and the answer is processed during the brief time when the countdown is about to run out. During this transition between processing the answer and the countdown running out, a bug happens that breaks the quiz and causes the system to go into a faulty state.

The issue:

When a user submits an answer, it’s processed, but during the time that the answer is being processed, the timer continues to run and might already expire, leading to a bug.

The bug occurs because the countdown and the answer processing are running in parallel and aren’t properly synchronized. This results in the system being in an invalid state when the timer expires.

How can I better synchronize the answer processing with the countdown so that the quiz flow doesn’t break?

Heres the code:

`require('dotenv').config();   
const { Client, GatewayIntentBits, ActionRowBuilder, ButtonBuilder, ButtonStyle, EmbedBuilder, Events } = require('discord.js');

const client = new Client({
    intents: [
        GatewayIntentBits.Guilds,
        GatewayIntentBits.GuildMessages,
        GatewayIntentBits.MessageContent,
    ],
});

const questions = [
    { 
        question: "Which chapter is known for their intense rage in battle, especially when near death?", 
        options: ["Blood Angels", "Space Wolves", "Iron Hands"], 
        answer: 0, 
        time: 10 
    },
    { 
        question: "What are the elite Imperial guards called who wear golden armor and protect the Emperor?", 
        options: ["Custodes", "Deathwatch", "Grey Knights"], 
        answer: 0, 
        time: 10 
    },
    { 
        question: "What is the armor color of the Ultramarines?", 
        options: ["Blue", "Red", "Green"], 
        answer: 0, 
        time: 10 
    },
    { 
        question: "Which Space Marine chapter is famously known for being cursed and suffering extreme misfortune in battle?", 
        options: ["Lamenters", "Blood Angels", "White Scars"], 
        answer: 0, 
        time: 10 
    },
    { 
        question: "Which Space Marine Chapter is known for its focus on protecting the innocent?", 
        options: ["Salamanders", "Blood Angels", "Space Wolves"], 
        answer: 0, 
        time: 10 
    },
    { 
        question: "Which Primarch is known for having angelic wings?", 
        options: ["Sanguinius", "Vulkan", "Horus"], 
        answer: 0, 
        time: 10 
    }
];
    




let leaderboard = {};
let activeQuestionIndex = 0;
let questionMessage = null;
let countdownInterval = null;
let userAnswers = {};
let messageCache = [];
let ephemeralMessages = { 
    savedAnswers: [], 
    alreadyAnswered: [], 
    quizRunningAlert: [] // Nachrichten, dass das Quiz bereits läuft
};
let quizActive = false; // Neue Variable, um zu prüfen, ob ein Quiz läuft
let startButtonMessage = null; // Variable, um die "Start Quiz"-Nachricht zu speichern

client.once('ready', () => {
    console.log('Der Bot ist online!');
});

client.on('messageCreate', async message => {
    if (message.author.bot) return;

    if (message.content === '!startquiz') {
        const row = new ActionRowBuilder()
            .addComponents(
                new ButtonBuilder()
                    .setCustomId('start_quiz')
                    .setLabel('Start Quiz')
                    .setStyle(ButtonStyle.Primary)
                    .setDisabled(quizActive) // Button deaktiviert, wenn ein Quiz läuft
            );

        startButtonMessage = await message.channel.send({
            content: 'Click the button to start the quiz!',
            components: [row]
        });
    }
});

client.on(Events.InteractionCreate, async interaction => {
    if (!interaction.isButton()) return;

    if (interaction.customId === 'start_quiz') {
        if (!quizActive) {
            quizActive = true; // Markiere das Quiz als aktiv
            await startQuiz(interaction.channel);
        } else {
            const alreadyStartedMessage = await interaction.reply({
                content: "A quiz is already running! Please wait until it is finished.",
                ephemeral: true
            });

            ephemeralMessages.quizRunningAlert.push(alreadyStartedMessage); // Speichern der Nachricht, dass das Quiz bereits läuft
        }
    } else if (interaction.customId.startsWith('answer_')) {
        await handleAnswer(interaction);
    }
});

function shuffle(array) {
    for (let i = array.length - 1; i > 0; i--) {
        const j = Math.floor(Math.random() * (i + 1));
        [array[i], array[j]] = [array[j], array[i]];
    }
}

async function startQuiz(channel) {
    leaderboard = {};
    activeQuestionIndex = 0;
    userAnswers = {};
    messageCache = [];
    ephemeralMessages = { savedAnswers: [], alreadyAnswered: [], quizRunningAlert: [] };

    // Auswahl von 10 zufälligen Fragen
    const selectedQuestions = [...questions];
    shuffle(selectedQuestions);
    const randomQuestions = selectedQuestions.slice(0, 10);

    // Fragenliste mit den ausgewählten Fragen ersetzen
    questions.length = 0; // Original-Liste leeren
    questions.push(...randomQuestions);

    await askNextQuestion(channel);
}


async function askNextQuestion(channel) {
    if (activeQuestionIndex >= questions.length) {
        return showFinalLeaderboard(channel);
    }

    const question = questions[activeQuestionIndex];
    await askQuestion(channel, question);
    activeQuestionIndex++;
}

async function askQuestion(channel, question) {
    let timeLeft = question.time;

    const embed = new EmbedBuilder()
        .setTitle("Question")
        .setDescription(question.question)
        .setFooter({ text: `Time left: ${timeLeft} Seconds` });

    const shuffledOptions = [...question.options];
    shuffle(shuffledOptions);

    const correctAnswerIndex = shuffledOptions.indexOf(question.options[question.answer]);

    const row = new ActionRowBuilder();
    shuffledOptions.forEach((option, index) => {
        row.addComponents(
            new ButtonBuilder()
                .setCustomId(`answer_${index}`)
                .setLabel(option)
                .setStyle(ButtonStyle.Primary)
        );
    });

    questionMessage = await channel.send({ embeds: , components: [row] });
    messageCache.push(questionMessage);

    countdownInterval = setInterval(async () => {
        timeLeft--;

        const updatedEmbed = EmbedBuilder.from(embed)
            .setFooter({ text: `Time left: ${timeLeft} seconds` });

        await questionMessage.edit({ embeds: [updatedEmbed] });

        if (timeLeft <= 0) {
            clearInterval(countdownInterval);
            await revealAnswers(channel, question, correctAnswerIndex, shuffledOptions);
        }
    }, 1000);
}

async function revealAnswers(channel, question, correctAnswerIndex, shuffledOptions) {
    const updatedRow = new ActionRowBuilder();
    shuffledOptions.forEach((option, index) => {
        updatedRow.addComponents(
            new ButtonBuilder()
                .setCustomId(`answer_${index}`)
                .setLabel(option)
                .setStyle(index === correctAnswerIndex ? ButtonStyle.Success : ButtonStyle.Danger)
                .setDisabled(true)
        );
    });

    const correctEmoji = "✅";
    const wrongEmoji = "❌";

    let resultMessage = "";
    for (const userId in userAnswers) {
        const isCorrect = userAnswers[userId] === correctAnswerIndex;
        resultMessage += `<@${userId}>: ${isCorrect ? correctEmoji + " **Right!**" : wrongEmoji + " **False!**"}n`;

        if (isCorrect) {
            const points = Math.floor(Math.random() * (100 - 0 + 1)) + 0;
            leaderboard[userId] = (leaderboard[userId] || 0) + points;
        }
    }

    const embed = EmbedBuilder.from(questionMessage.embeds[0])
        .setFooter({ text: "Time's up!" })
        .setColor(0xFF0000)
        .setDescription(`${question.question}nn${resultMessage}`);

    await questionMessage.edit({ embeds: , components: [updatedRow] });

    userAnswers = {};
    setTimeout(async () => {
        await askNextQuestion(channel); 
    }, 5000);
}

async function handleAnswer(interaction) {
    const [_, answerIndex] = interaction.customId.split('_');
    const answer = parseInt(answerIndex);

    if (userAnswers[interaction.user.id] !== undefined) {
        const alreadyAnsweredMessage = await interaction.reply({
            content: "You have already submitted an answer.",
            ephemeral: true
        });

        ephemeralMessages.alreadyAnswered.push(alreadyAnsweredMessage); // Füge diese Nachricht zu den "bereits geantwortet" Nachrichten hinzu
        return;
    }

    userAnswers[interaction.user.id] = answer;

    const updatedRow = new ActionRowBuilder();
    questionMessage.components[0].components.forEach((button, index) => {
        updatedRow.addComponents(
            ButtonBuilder.from(button)
                .setStyle(ButtonStyle.Primary)
        );
    });

    const selectedAnswer = questionMessage.components[0].components[answer].label;
    const replyMessage = await interaction.reply({
        content: `${selectedAnswer} was logged in`,
        ephemeral: true
    });

    ephemeralMessages.savedAnswers.push(replyMessage);
    await interaction.message.edit({ components: [updatedRow] });
}

async function showFinalLeaderboard(channel) {
    const sortedPlayers = Object.entries(leaderboard).sort((a, b) => b[1] - a[1]).slice(0, 5);
    const description = sortedPlayers.map(([userId, score], i) => `${i + 1}. <@${userId}>: ${score} Punkte`).join('n');

    const embed = new EmbedBuilder()
        .setTitle("🏆 Final score 🏆")
        .setDescription(description || "No players.")
        .setColor(0xFFD700);

    const leaderboardMessage = await channel.send({ embeds:  });

    let countdown = 15;

    countdownInterval = setInterval(async () => {
        await leaderboardMessage.edit({
            embeds: [EmbedBuilder.from(embed).setFooter({ text: `End in ${countdown} seconds` })]
        });

        countdown--;

        if (countdown <= 0) {
            clearInterval(countdownInterval);
            await cleanUpAfterQuiz(channel, leaderboardMessage);
        }
    }, 1000);
}

async function cleanUpAfterQuiz(channel, leaderboardMessage) {
    try {
        await leaderboardMessage.delete();
        console.log("Leaderboard-Nachricht gelöscht.");
    } catch (error) {
        console.error("Fehler beim Löschen der Leaderboard-Nachricht:", error);
    }

    // Lösche alle gespeicherten Nachrichten
    for (const msg of messageCache) {
        await msg.delete().catch(err => console.error("Fehler beim Löschen der Nachricht:", err));
    }

    // Lösche alle ephemeren Nachrichten, die für Benutzer sichtbar waren
    for (const msg of ephemeralMessages.savedAnswers) {
        await msg.delete().catch(err => console.error("Fehler beim Löschen der ephemeren Nachricht:", err));
    }

    // Lösche die Nachrichten, dass der Benutzer bereits geantwortet hat
    for (const msg of ephemeralMessages.alreadyAnswered) {
        await msg.delete().catch(err => console.error("Fehler beim Löschen der Nachricht (bereits geantwortet):", err));
    }

    // Lösche die Nachrichten, dass das Quiz bereits läuft
    for (const msg of ephemeralMessages.quizRunningAlert) {
        await msg.delete().catch(err => console.error("Fehler beim Löschen der Nachricht (Quiz läuft bereits):", err));
    }

    // Deaktiviere den Button
    const row = new ActionRowBuilder()
        .addComponents(
            new ButtonBuilder()
                .setCustomId('start_quiz')
                .setLabel('Start Quiz')
                .setStyle(ButtonStyle.Primary)
                .setDisabled(true)
        );

    // Deaktiviere den Button in der bestehenden Nachricht
    if (startButtonMessage) {
        await startButtonMessage.edit({
            content: 'The quiz is over. Click to start a new quiz!',
            components: [row]
        });
    }

    // Zurücksetzen des Quiz-Status
    quizActive = false;
}

client.login(process.env.BOT_TOKEN);`

The answer processing takes longer than expected, and by the time the user’s answer is processed, the countdown has already expired. This causes the quiz to enter an invalid state, as the system isn’t synchronized properly when the timer expires.