Mais ou est la faute dans cet algorithme de Tic-Tac-Toe ecrit en C++ ?

Version imprimable

Salut, encore une fois,
Il y'a deux jours, J'ai ecrit un Tic-Tac-Toe PLAYER 1 vs PLAYER 2, tout marche bien, la grille s'affiche, elle se remplit par X ou O apres le choix d'une case...presque tout marche bien, sauf l'étape du test si le PLAYER a gagné ou pas. Bon voila le code source :

Code:

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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
#include <iostream>
#include <string>
#include <cstdlib>
using namespace std;
bool victoire1( char player[], int taille);//fonction qui examine le tableau de PLAYER 1. prend en arguments le tableau de PLAYER 1 et sa taille . examine le tableau, s'il y'a 3 marques allignées la fonction retourne true, sinon retourne false.
bool victoire2( char player[], int taille);//fonction qui examine le tableau de PLAYER 2. prend en arguments le tableau de PLAYER 2 et sa taille . examine le tableau, s'il y'a 3 marques allignées la fonction retourne true, sinon retourne false.
void afficherGrille( char grillePrincipale[], int taille);//fonction qui dessine une grille de Tic-Tac-Toe en faisant les mises a jour de la grille. prend en arguments les deux tableaux action1[] et actions2[] et leurs taille. ne renvoient rien mais dessine dans la console output
int main()
{
    string confirmation ;
    int choix1, choix2;//choix1 va contenir le nombre du carreau choisi par le PLAYER 1, tandis que choix2 va contenir celui de PLAYER2
    const int taille = 9;//Taille du tableau represente la grille du jeu 3x3
    int roles = 0;//a chaque 2 nouveux tours ( quand PLAYER 1 et PLAYER 2 finissent 1 tour) passent, on ajoute 1 a roles, elle est indispensable pour le fonctionnement de l'egalite
    bool commencer=false, dejaChoisie;//commencer est false pour ne pas reintialiser les tableaux( il y'a une instruction qui examine commencer a la fin destours de PLAYER 1 et PLAYER 2), car quand elle est true, sa veut dire qu'on veut recommencer la partie et donc reintialiser les tableaux. dejaChoisie prend true si le choix du joueur est deja selectionné par le meme joueur ou par un autre, et prend false sinon
    char actions1[ taille]={ '1', '2', '3', '4', '5', '6', '7', '8', '9'};//va contenir les carreaux remplits par PLAYER1
    char actions2[ taille]={ '1', '2', '3', '4', '5', '6', '7', '8', '9'};//va contenir les carreaux remplits par PLAYER2
    char grillePrincipale[ taille]={ '1', '2', '3', '4', '5', '6', '7', '8', '9'};// celle qui va etre transmis a l'ecran, elle va contenir X et O et les nombres non-remplis
    do
    {
        if ( !victoire2(actions2, taille) && !commencer)
        {
            afficherGrille( grillePrincipale, taille);
            cout<<"PLAYER 1: Entrez le nombre de carreau ou vous voulez placer le X: ";//tour de PLAYER 1
            do
            {
                commencer = false;//pour ne pas reintialiser le jeu
                dejaChoisie = false;//pour que la boucle ne sois pas infinie
                cin>>choix1;//Lire le nombre de carreau dont le PLAYER 1 veut poser le X
                if ( grillePrincipale[ choix1-1] == 'X' || grillePrincipale[ choix1-1] == 'O')//demandez une autre fois un nombre de carreau car celui qui est entré est deja selectionné par PLAYER 1 ou par PLAYER 2
                {
                    if (grillePrincipale[ choix1-1] == 'X')
                    {
                        cout<<"Vous avez deja choisis cette case."<<endl;
                    }
                    else if (grillePrincipale[ choix1-1] =='O')
                    {
                        cout<<"Cette case est deja choisie par votre adversaire."<<endl;
                    }
                    dejaChoisie=true;//dans les deux cas la case est deja choisie
                }
                else if ( choix1 > 0 && choix1 <= taille && grillePrincipale[ choix1-1] != 'X' && grillePrincipale[ choix1-1] != 'O')
                {
                    actions1[ choix1-1]='X';//remplir la case "choix1-1"("-1" car les subscripts sont decales de 1, par exemple si le joueur choisi 5 sa veut dire qu'il faut remplir la case 4 ( qui fait reference a l'icone 5 de la grille du jeu) du tableau  par X appartenant a PLAYER 1
                    grillePrincipale[ choix1-1]=actions1[ choix1-1];//remplir aussi le tableau grillePrincipale par X
                }
                else if ( choix1 <= 0 || choix1 > 9)
                {
                    cout<<"Entrez un identifiant de carreau valide :"<<endl;
                }
                else if ( victoire1(actions1, taille) || roles==5)
                {
                    cout<<"OUIIIIIIIIIIII"<<endl;
                    if (victoire1(actions1, taille))//Si victoire(actions1, taille) est true
                    {
                        afficherGrille( grillePrincipale, taille);
                        cout<<"PLAYER 1 gagne !"<<endl;
                    }
                    else if((!victoire1(actions1, taille))&&(!victoire2(actions2, taille)))
                    {
                        afficherGrille( grillePrincipale, taille);
                        cout<<"Egalite.";
                    }
                    cout<<"Voulez-vous reessayer ? (Y/N): ";
                    cin>>confirmation;
                    while( confirmation != "Y" && confirmation !="y" && confirmation !="N" && confirmation !="n")
                    {
                        cout<<"N'entrez que Y ou N : ";
                        cin>>confirmation;
                    }
                    if ( confirmation == "Y" || confirmation == "y")
                    {
                        commencer = true;
                    }
                }
            }while ( choix1 <= 0 || choix1 > 9 || dejaChoisie==true);//pour demander a chaque fois la variable choix1 si choix1 <= 0 || choix1 > 9 || si la case est deja choisie par PLAYER1 ou PLAYER2
        }
        else if (!victoire1(actions1, taille) && !commencer);//si victoire(actions1, taille) est false
        {
            afficherGrille( grillePrincipale, taille);
            cout<<"PLAYER 2: Entrez le nombre de carreau ou vous voulez placer le O: ";//tour de PLAYER 2
            roles+=1;//Si on l'inclut dans la boucle, a chaque fois que le joueur n'entre pas un identifiant valide, roles va s'incrementer, on definit alors la fin de 1 tour ici apres que le programme demande d'entrer un identifiant
            do
            {
                dejaChoisie = false;
                cin>>choix2;//Lire le nombre de carreau dont le PLAYER 1 veut poser le X
                if ( grillePrincipale[ choix2-1] == 'X' || grillePrincipale[ choix2-1] == 'O')//demandez une autre fois un nombre de carreau car celui qui est entré est deja selectionné par PLAYER 1 ou par PLAYER 2
                {
                    if (grillePrincipale[choix2-1] == 'O')
                    {
                        cout<<"Vous avez deja choisis cette case."<<endl;
                    }
                    else if (grillePrincipale[choix2-1]=='X')
                    {
                        cout<<"Cette case est deja choisie par votre adversaire."<<endl;
                    }
                    dejaChoisie = true;//dans les deux cas la case est deja choisie
                }
                else if ( choix2 > 0 && choix2 <= taille && grillePrincipale[ choix2-1] != 'O' && grillePrincipale[ choix2-1] != 'X')
                {
                    actions2[ choix2-1]='O';//remplir la case "choix2-1"("-1" car les subscripts sont decales de 1, par exemple si le joueur choisi 5 sa veut dire qu'il faut remplir la case 4 ( qui fait reference a l'icone 5 de la grille du jeu) du tableau  par 0 appartenant a PLAYER 2
                    grillePrincipale[choix2-1]=actions2[ choix2-1];//remplir aussi le tableau grillePrincipale[] par O
                }
                else if ( choix2 <= 0 || choix2 > 9)
                {
                    cout<<"Entrez un identifiant de carreau valide :"<<endl;
                }
                else if ( victoire2(actions2, taille) || roles == 5)
                {
                    if (victoire2(actions2, taille))//Si victoire(actions2, taille) est true
                    {
                        afficherGrille( grillePrincipale, taille);
                        cout<<"PLAYER 2 gagne !"<<endl;
                    }
                    else if((!victoire1( actions1, taille))&&(!victoire2( actions2, taille)))
                    {
                        afficherGrille( grillePrincipale, taille);
                        cout<<"Egalite.";
                    }
                    cout<<"Voulez-vous reessayer ? (Y/N): ";
                    cin>>confirmation;
                    while( confirmation != "Y" && confirmation !="y" && confirmation !="N" && confirmation !="n")
                    {
                            cout<<"N'entrez que Y ou N : ";
                            cin>>confirmation;
                    }
                    if ( confirmation == "Y" || confirmation == "y")
                    {
                        commencer = true;
                    }
                }
            }while ( choix2 <= 0 || choix2 > 9 || dejaChoisie);//pour demander a chaque fois la variable choix2 si choix2 <= 0 || choix2 > 9 || choix1 == choix2
        }
        if( commencer) //pour réintialiser les icones apres un redemarrage de la partie.
        {
            for ( int subscript=0, intialisation=1; subscript<taille; subscript++, intialisation++)//raccourcis en utilisant for pour affecter les cases des trois tableaux de 0-8 par 1-9 successivement.
            {
                actions1[subscript]=intialisation;
                actions2[subscript]=intialisation;
                grillePrincipale[subscript]=intialisation;
            }
        }
    }while ( commencer || (((!victoire1( actions1, taille)) && (!victoire2( actions2, taille)))));
    if ( confirmation == "N" || confirmation == "n")
    {
        cout<<"Merci d'avoir teste le jeu"<<endl;
        system("PAUSE");
    }
    return 0;
}
bool victoire1( char player[], int taille)
{
    if (( player[0]=='X' &&player[1]=='X' &&player[2]=='X') || ( player[0]=='X' &&player[3]=='X' &&player[6]=='X' ) || ( player[0]=='X' &&player[4]=='X' &&player[8]=='X' ) || ( player[1]=='X' &&player[4]=='X' &&player[7]=='X' ) || ( player[2]=='X' &&player[4]=='X' &&player[6]=='X' ) || ( player[2]=='X' &&player[5]=='X' &&player[8]=='X' ) || ( player[3]=='X' &&player[4]=='X' &&player[5]=='X' ) || ( player[6]=='X' &&player[7]=='X' &&player[8]=='X'))
    {
        return true;
    }
    else
    {
        return false;
    }
}
bool victoire2( char player[], int taille)
{
    if (( player[0]=='O' &&player[1]=='O' &&player[2]=='O') || ( player[0]=='O' &&player[3]=='O' &&player[6]=='O' ) || ( player[0]=='O' &&player[4]=='O' &&player[8]=='O' ) || ( player[1]=='O' &&player[4]=='O' &&player[7]=='O' ) || ( player[2]=='O' &&player[4]=='O' &&player[6]=='O' ) || ( player[2]=='O' &&player[5]=='O' &&player[8]=='O' ) || ( player[3]=='O' &&player[4]=='O' &&player[5]=='O' ) || ( player[6]=='O' &&player[7]=='O' &&player[8]=='O'))
    {
        return true;
    }
    else
    {
        return false;
    }
}
void afficherGrille( char grillePrincipale[], int taille)
{
    int subscript = 0;//va definir les cases a afficher
    cout<<endl<<"                                ---+---+---"<<endl;
    for ( int sauter = 0; sauter < 3; sauter++, subscript+=3)
    {
        cout<<"                               |";
        for ( int remplir = subscript; remplir < subscript + 3; remplir++)//On va afficher les valeurs des cases 0-1-2, quand remplir va prendre la valeur 3, la boucle va arreter puis la boucle generale va redemarrer une deuxieme fois, on ajoute alors 3 a subscript, puis on entre dans la boucle secondaire ( d'affichage) pour afficher les valeurs dans les cases 3-4-5,.............. pour afficher les valeurs dans les cases 6-7-8
        {
            cout<<" "<<grillePrincipale[ remplir]<<" |";
        }
        cout<<endl<<"                                ---+---+---"<<endl;
    }
    cout<<endl;
}

Le probleme c'est que je ne sais pas ou est la faute dans cet algorithme, normalement il faut distinguer si le joueur gagne aprés chaque mise d'un X ou d'un O, mais la rien ne s'affiche. Quand, par exemple, on met trois X allignés, le programme demande d'entrer un O.
Je vous invite a compiler et executer le code pour mieux comprendre.
A bientot.

Bonjour,

ton programme présente d'autres problèmes.
- Tu commences par vérifier si la case choisie par choix1 est occupée ou non avant de vérifier si l'identifiant de la case est correcte (1-9) : crash si je choisis un nombre invalide
- Peut-être la source de ton "problème" mais pourquoi ne test de victoire est un else if à la sélection de la case à jouer ?!
Ce test doit être indépendant de la case où l'on joue, ou plutôt il doit toujours être réalisé après chaque jeu.

Ton problème est donc un problème d'algorithmique
Code:

1 2 3 4 5 6 7 8 // initialisation du plateau // tant qu'il n'y a pas de victoire // joueur 1 choisit la case où jouer // si joueur 1 gagne : gagné // joueur 2 choisit la case où jouer // si joueur 2 gagne : gagné // proposer de rejouer : retour à l'initialisation

11/06/2012, 13h26
lahdili.reda

Merci Bousk, j'essayerait de corriger les erreurs et de mettre " résolut " a la discussion si j'arrive a résoudre le probléme.

Salut,

D'abord, pourrais tu pourquoi tu as créé victoire1 et victoire2 :question:

Après tout, la seule différence tient au caractère utilisé pour la vérification...

Tu pourrais donc parfaitement éviter une copie de code (et donc éviter le risque de modifier victoire1 sans répercuter le changement équivalent dans victoir2) en rajoutant un paramètre à ta fonction:
Code:

1 2 3 4 5 6 7 8 9 10 11 bool victoire1( char player[], int taille, char tocheck) { if (( player[0]==tocheck &&player[1]==tocheck &&player[2]==tocheck) || ( player[0]==tocheck &&player[3]==tocheck &&player[6]==tocheck ) || ( player[0]==tocheck &&player[4]==tocheck &&player[8]==tocheck ) || ( player[1]==tocheck &&player[4]==tocheck &&player[7]==tocheck ) || ( player[2]==tocheck &&player[4]==tocheck &&player[6]==tocheck ) || ( player[2]==tocheck &&player[5]==tocheck &&player[8]==tocheck ) || ( player[3]==tocheck &&player[4]==tocheck &&player[5]==tocheck ) || ( player[6]==tocheck &&player[7]==tocheck &&player[8]==tocheck )) { return true; } else { return false; } }
De plus, la logique qui consiste à vérifier toutes les possibilités est, disons le clairement, "moyen moyen" :aie:

Car, si tu décides, plus tard, de permettre de jouer avec des grilles de 4 par 4 ou de 5 par 5, tu te trouveras devant l'obligation de revoir cette logique, et de vérifier 7 possibilités (pour une grille 3 par 3) +10 possibilités (pour une grilel 4 par 4) + 12 possibilités (pour une grille 5 par 5), et tu ne pourras pas généraliser ton code :aie:

D'autant plus que tu transmet une information de taille à ta fonction et que celle-ci n'est jamais utilisée!

En prévoyant une variable qui pourrait représenter le nombre de lignes (ou de colonnes, vu que l'on part sur une grile carrée), que l'on multipliera avantageusement par elle même pour avoir la taille réelle du tableau, il devient possible de s'arranger pour que toutes les vérifications se fassent sur deux boucles à peine, quelle que soit la taille de la grille, sous une forme proche de
Code:

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 bool victoire1( char player[], int taille, char tocheck) { for(int i = 0; i< taille; ++i ) { bool winsInRow = true; bool winsInColumn = true; bool winsInDiagTopLeft = i == 0; bool winsInDiagTopRight = i == taille-1; for( int j = 0; j < taille; ++j) { /* on vérifie la ligne */ if(player[ i * size + j]!= tocheck) { winsInRow = false; } /* on vérifie la colonne*/ if(player[ i + j * size]!= tocheck) { winsInRow = false; } /* on vérifie la diagonale gauche */ if(i == 0) { if(player[j * size + j ]!= tocheck) { winsInDiagTopLeft = false; } } /* on vérifie la diagonale droite */ if(i == taille - 1) { if(player[j * size + size - j]!= tocheck) { winsInDiagTopRight = false; } } } if( winsInRow || winsInColumn || winsInDiagTopLeft || winsInDiagTopRight ) { return true; } } }
qui s'addaptera à n'importe quelle grille carrée.

Ensuite, une fonction qui fait plus de 140 lignes, pour la fonction main, c'est vraiment excessif!!! (et pour tout autre fonction, d'ailleurs :P)

surtout que tu en arrives allègrement à avoir six ou huit niveau d'indentation différents, et que ta fonction principale se retrouve avec les responsabilités :

d'initialiser le jeu
de demande au joueur le carreau qu'il veut utiliser
de valider le choix du joueur
de décider éventuellement de redemander au joueur
d'agir en fonction d'une éventuelle victoire qu'elle doit tester
peut etre d'autres encore qui m'auraient échappé
S'il y a un principe qu'il est important d'assimiler très rapidement, c'est le principe dit "ORP" pour One Responsability Principle, ou, si tu préfères, le principe de la responsabilité unique:

Il est en effet important de veiller à ce que toute classe ou fonction n'ait qu'une responsabilité mais qu'elle s'en acquite correctement.

Si donc une fonction se retrouve à avoir plus d'une responsabilité, c'est, très clairement, qu'elle en a trop ;)

Tu devrais donc commencer par essayer de déterminer les différentes responsabilités sus-citées et par faire en sorte qu'elles soient prises en charge chaque fois par une fonction qui ne s'occupe que de cela.

tu verras, tu te retrouveras beaucoup plus facilement dans ton code avec un nombre plus important de petites fonctions qui font peut de choses qu'avec une seule fonction dont on s'étonnerait presque qu'elle ne fasse pas le café ;)

Ce que j'ai tres bien saisi c'est qu'il faut que j'evolue ma fonction victoire, pour qu'elle soit plus efficace, et de la planter dans le bon endroit dans le code, dans le but de s'encharger parfaitement du travail.
J'ai trouvé une solution efficace, pas plus efficace que celle de koala01 :ccool:. elle consiste a organiser un autre tableau avec des nombres précis définis par le MagicSquare ( visitez http://mathworld.wolfram.com/MagicSquare.html pour mieux comprendre).
Voici l'extrait du code mis a jour :

Code:

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
bool victoire( int toTest[], int taille);
.
.
.//Entrant dans main()
.
.
    const int taille = 9;
    int magicSquare[taille];
    int choix1, choix2;
    const int taille = 9;
    int magicSquare[ taille]={ 8, 1, 6, 3, 5, 7, 4, 9, 2};
    int magicSquareVide1[ taille];
    int magicSquareVide2[ taille];
    for ( int count = 0; count < taille; count++)
    {
        magicSquareVide[count] = 0;//car je m'en doute si les tableaux sont intialisés par defaut avec 0, c'est pourquoi je les ai intialisé par moi-meme avec.
    }
    char actions1[ taille]={ '1', '2', '3', '4', '5', '6', '7', '8', '9'};
    char actions2[ taille]={ '1', '2', '3', '4', '5', '6', '7', '8', '9'};
    char grillePrincipale[ taille]={ '1', '2', '3', '4', '5', '6', '7', '8', '9'};
.
.
.//comme le code de mon premier post
.
.
    else if ( choix1 > 0 && choix1 <= taille && grillePrincipale[ choix1-1] != 'X' && grillePrincipale[ choix1-1] != 'O')
    {
        actions1[ choix1-1]='X';
        grillePrincipale[ choix1-1]=actions1[ choix1-1];
        magicSquareVide1[ choix1-1]=magicSquare[ choix-1];//pour intialiser le nombre disons "magique" dans la case choix1-1 de magicSquare dans magicSquareVide
    }
.
.
.
.
.
    if (victoire(magicSquareVide1, taille))
        {
            afficherGrille( grillePrincipale, taille);
            cout<<"PLAYER 1 gagne !"<<endl;
        }
 
.
.
.//meme processus avec PLAYER2
.
.
 
.
.
.//sortant de main() vers la definition des fonctions
.
.
bool victoire( int toTest[], int taille)
{
    if( (toTest [0] + toTest[1] + toTest[2] == 15) ||(toTest [3] + toTest[4] + toTest[5] == 15)(toTest [6] + toTest[7] + toTest[8] == 15)(toTest [0] + toTest[4} + toTest[8] == 15)//...
        return true;
    else 
        return false
}

Notez qu'on peut créer un MagicSquare avec x systèmes d'équations, x est le nombre de carreau dans cette grille.
kola01, j'ai tres bien aimé tes trois dernieres lignes, je vais essayer d'apprendre par coeur cette morale pendant toute ma carriere de programmeur, et pendant toute la vie puisqu'elle fonctionne avec le café, et donc avec tout les processus algorithmiques. ;)