Attendre la fin d'une instruction avant de modifier une variable

Bonjour,

Je souhaite faire en sorte qu’aucun jeu ne soit fait simultanément. Voici la fonction exécutant le jeu :

async exec(msg, args) {
    const hr = new HorsengelRoulette(msg, msg.member, args.provoked, config.prefix, config.language);
    hr.load(6, 1);
    hr.start(msg);
}

J’avais pensé à utiliser une variable du style isGame = false et vérifier cette condition avant d’exécuter ces trois lignes. Je sais qu’avant la constante, il suffirait de modifier la valeur à true mais je ne sais pas comment faire pour remettre la valeur à false.

En effe, start() exécute une multitude d’instructions et il y a plusieurs conditions possibles pour une fin de jeu. J’ai pensé à ajouter un await avant la dernière ligne mais je ne suis pas très bon avec l’asynchrone donc je ne sais pas si ça donnera ce que je cherche.

Quels méthodes pourraient apporter une solution ?

Bonjour,

Je ne comprends pas le but de ton algorithme. Une petite recherche Google m’a permis d’apprendre qu’il s’agit d’un bot Discord, ça aurait été bien de le préciser.

Donc si je remets les choses dans l’ordre, tu as un ou plusieurs joueurs qui peuvent jouer à la roulette et il ne faut pas que tous les jeux se mélangent ? Si oui, il te faut prévoir une stack (pile) dans laquelle tu stocks les informations du joueur (ou plus ?). A l’appel de ta fonction, si un élément se trouve dans ta stack, tu empiles, sinon tu joues (en modifiant un booléen pour savoir qu’un jeu est en cours). Puis une fois que tu as fini un jeu, tu dépiles ta stack par le bas (First-In First-Out) pour prendre le suivant et rebelote jusqu’à ce que ta stack soit vide.

Je ne pensais pas que le détail d’un bot Discord était essentiel pour résoudre le problème.

En fait, je veux qu’il n’y ait qu’une partie de lancé à la fois.

Il nous faudrait un code d’exemple un peu plus élaboré pour te répondre, il y a plein de moyen possible.

La plus commune c’est de renseigner une fonction callback en argument.

const onEnd = () => {
  console.log("c'est fini !")
}

hr.start(msg, onEnd)

Mais si pour jouer tu attends la réponse d’une personne et non un temps impartie, je te conseillerai de gérer chaque tour indépendamment (comme requête HTTP vers un script php, chaque script/requête est indépendant de l’une et de l’autre). Ce que je veux dire par la, c’est qu’il ne devrait pas avoir d’imbrication dans ton code entre chaque tour, ce n’est pas ton code qui doit lancer la suite mais bien la réception du nouveau message (car l’événement est externe).

Quand je parle d’imbrication je veux dire :

function Partie() {
  // initialisation
}

Partie.prototype.tour = function (arg1, arg2, onEnd) {
  // ton code

  onEnd.bind(this)
}

tour(0, 'sometext', function () {
  tour()
})

// ou `tour(0, 'sometext', tour)

Ce code est bien mais ça sous entend que quand tu reçois un message tu sais parfaitement que le message en question est lié à ce tour.

Une autre solution serait de mapper ta classe en fonction du numéro de partie. Quand la personne te répond à nouveau, tu identifies quelle partie est en cours. Par exemple :

let currentParty = null;

function Partie() {
  // initialisation
}

Partie.prototype.digestResponse = function (data) {
  // ton code

  this.nextLap()
}

// Pour creer une partie
function makeGame() {
  if (!(currentParty === null || currentParty.isEnded()))
    return console.log("pas de nouvelle partie")

  currentParty = new Party()
}

// Pour lancer le prochain tour
function onMessage(data) {
  currentParty.digestResponse(data) // et la dedans tu fais this.nextLap()
}

EDIT : Je me demande si je réponds bien à ton problème :-/

Pour être sûr : Tu sais que let, const et var peuvent être toute les trois globales ?