Discussion :

[davidbret]

Bonjour ,

je poste mon code d'un petit jeu mais je bloque au niveau de temps écoulé il fait la boucle mais reste bloqué en attente ?

je pense qu'ici il y aura surement des compétents.
je précise que je commence le c++ dans mon code j'ai récupéré le bout de code avec future et chrono car il avait de faire ce que je voulais c'est a dire un compte à rebours avec un cin mais là je bloque. merci de votre compréhension j'espère avoir été claire dans mon explication.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
#include <iostream>
#include <ctime>
#include <cstdlib>
#include <string>
#include <future>
#include <thread>
#include <chrono>
#include <unistd.h>
 
static std::string getAnswer()
{
    std::string answer;
    std::cin >> answer;
    return answer;
}
 
std::string melangerlettres(std::string mot)
{
    std::string melange;
    int position(0);
 
    while (mot.size() != 0)
    {
        position = rand() % mot.size();
        melange += mot[position];
        mot.erase(position, 1);
    }
    return melange;
}
 
int main()
{
    std::string motMystere, motMelange, motUtilisateur, reponseRejouer;
    srand(time(0));
 
    std::chrono::seconds timeout(5);
 
    do
    {
        std::system("clear");
 
        std::cout << "mot mystere: " << std::endl;
        std::cin >> motMystere;
 
        std::system("clear");
 
        int nombreCoups = motMystere.size();
 
        motMelange = melangerlettres(motMystere);
 
        do
        {
            motUtilisateur = "perdu";
 
            std::cout << "nombre restant d'essais : " << nombreCoups << std::endl;
            std::cout << "\nQuel est ce mot : " << motMelange << std::endl;
 
            std::future<std::string> future = std::async(getAnswer);
 
            if (future.wait_for(timeout) == std::future_status::ready)
            {
                motUtilisateur = future.get();
            }
 
            std::cout << "heheheheheh" << std::endl;
            //std::system("clear");
            nombreCoups -= 1;
 
            if (nombreCoups < 1)
            {
                std::cout << "COUPS DEPASSES." << std::endl;
                motUtilisateur = motMystere;
            }
            else
            {
                if (motUtilisateur != motMystere)
                {
                    std::cout << "NON RECOMMENCE." << std::endl;
                }
                else
                {
                    std::cout << "BRAVO." << std::endl;
                }
            }
        } while (motUtilisateur != motMystere);
 
        std::cout << "\nVoulez-vous rejouer ? (o/n)" << std::endl;
        std::cin >> reponseRejouer;
 
    } while (reponseRejouer == "o" || reponseRejouer == "O");
 
    return 0;
}

[dalfab]

Bonjour,

Quand tu appelles async(), tu n'indiques pas que tu veux un traitement asynchrone. Il faut le préciser car sinon le système peut choisir, et risque de faire un appel synchrone.
Ensuite, s'il y a temps écoulé, tu décides d'oublier l'attente pour en faire une nouvelle. Mais l'async est toujours actif, donc l'utilisateur devra entrer le premier mot, puis ressaisir le second pour qu'il soit analysé, le tout en moins de 5 secondes. Si l'utilisateur est très lent, c'est 3 4 5 voire plus de mots à saisir.
Il faudrait abandonner la saisie en cas de temps écoulé, je ne connais pas de moyen dans le C++ standard. Sinon on pourrais attendre le mot et l'ignorer avant de continuer. Ça donne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
         std::future<std::string> future = std::async( std::launch::async, getAnswer );
 
         if ( future.wait_for( timeout ) == std::future_status::ready ) {
            motUtilisateur = future.get();
         }
         else {
            std::cout << " trop tard, ton mot sera refusé, finis la saisie" << std::endl;
            future.wait();  // attendre la fin, avant de continuer
         }

[davidbret]

tout d'abord merci.

la partie async je pense avoir compris mais part contre le reste j'ai un peu de mal a suivre.

La où je ne suis pas le code, c'est lorsque le code attend une frappe après les 5 secondes alors qu'il a bien pris en compte que part default motUtilisateur est bien "perdu", il suis bien la condition if pour recommencer mais bloque en attendant une frappe et touche entré pour répéter la boucle car si je n'attend pas les 5 secondes le code fonctionne très bien, c'est là que je ne comprend pas.

je sais pas si j'ai été très claire de mon côté.

[dalfab]

Oui, s'il s'est écoulé moins de 5 secondes, ton code récupère la valeur et la gère correctement.
Mais si au bout de 5 secondes la touche entrée n'a toujours pas été tapée, ton code continue en "oubliant" l'entrée mais le async() lui est toujours en train d'attendre la fin de la saisie, on ne peut pas le "tuer". Donc la prochaine saisie ne sera lue par personne, mais il faudra quand même la faire. D'où mon code où dans ce cas j'attend cette fin de saisie.
essaie les 2 codes pour voir ce qu'il se passe.