Donc voilà, en attendant la seconde partie, mon code avec le mode humain vs humain, et le monde humain vs IA :
Code unixoïdes :
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void Afficher(char c[]);
int verif_fin(char c[], char car);
int verif_case(char c[], int pos);
int ia(char c[]);
int main(void)
{
int end=1, win1=0, win2=0, win3=0, j, fin, pos, possible, choix=1;
char c[9], car;
do {
system("clear");
printf("\n\t1 ou 2 joueurs ?\n");
scanf("%d", &choix);
} while (choix != 1 && choix != 2);
do {
c[0] = '1', c[1] = '2', c[2] = '3', c[3] = '4', c[4] = '5', c[5] = '6', c[6] = '7', c[7] = '8', c[8] = '9';
fin=0;
possible=1;
srand(time(NULL));
j = (rand() % (2 - 1 + 1)) + 1;
system("clear");
Afficher(c);
do {
if (j == 1)
{
if (pos >=1 && pos <=9 && car == 'O' && choix == 1)
{
printf("\n(l'IA a joué en %d )\n", pos);
}
printf("\n Joueur 1 :\t");
scanf("%d", &pos);
j = 2;
car = 'X';
possible = verif_case(c, pos);
if (possible == 0 || pos > 9 || pos < 1)
{
do {
printf("\n Case déjà remplie, ou mauvais chiffre entré. Veuillez recommencer :\t");
scanf("%d", &pos);
possible = verif_case(c, pos);
} while (possible == 0);
}
}
else
{
if (choix == 2)
{
printf("\n Joueur 2 :\t");
scanf("%d", &pos);
j = 1;
car = 'O';
possible = verif_case(c, pos);
if (possible == 0 || pos > 9 || pos < 1)
{
do {
printf("\n Case déjà remplie, ou mauvais chiffre entré. Veuillez recommencer :\t");
scanf("%d", &pos);
possible = verif_case(c, pos);
} while (possible == 0);
}
}
else
{
pos = ia(c);
j = 1;
car = 'O';
possible = verif_case(c, pos);
if (possible == 0)
{
do {
pos = ia(c);
possible = verif_case(c, pos);
} while (possible == 0);
}
}
}
c[pos-1] = car;
system("clear");
Afficher(c);
fin = verif_fin(c, car);
} while (fin == 0);
car = ' ';
if (fin == 3)
{
printf("\nMatch nul.\n");
win3++;
}
if (fin == 1)
{
printf("\nVous avez gagné.\n");
win1++;
}
if (fin == 2)
{
printf("\nVous avez perdu.\n");
win2++;
}
printf("\n\tRejouer ?\t1. Oui\n\t\t\t2. Non\t\t");
scanf("%d", &end);
} while (end == 1);
if (win1 > win2 && choix == 2)
{
printf("\nVictoire %d à %d du joueur 1 (%d match(s) nul(s)).\n\n", win2, win1, win3);
}
if (win1 > win2 && choix == 1)
{
printf("\nVous avez gagné %d à %d (%d match(s) nul(s)).\n\n", win1, win2, win3);
}
if (win1 == win2)
{
printf("\nÉgalité %d partout (%d match(s) nul(s)).\n\n", win1, win3);
}
if (win1 < win2 && choix == 2)
{
printf("\nVictoire %d à %d du joueur 2 (%d match(s) nul(s)).\n\n", win2, win1, win3);
}
if (win1 < win2 && choix == 1)
{
printf("\nVictoire %d à %d de l'IA (%d match(s) nul(s)).\n\n", win2, win1, win3);
}
return 0;
}
////////////////////////////////////////////////////////////////
void Afficher(char c[])
{
printf("\n\t\t ___________");
printf("\n\t\t| | | |");
printf("\n\t\t| %c | %c | %c |", c[0], c[1], c[2]);
printf("\n\t\t|___|___|___|");
printf("\n\t\t| | | |");
printf("\n\t\t| %c | %c | %c |", c[3], c[4], c[5]);
printf("\n\t\t|___|___|___|");
printf("\n\t\t| | | |");
printf("\n\t\t| %c | %c | %c |", c[6], c[7], c[8]);
printf("\n\t\t|___|___|___|\n");
}
int verif_fin(char c[], char car)
{
int fin = 0;
if ( (c[0] == c[1] && c[1] == c[2]) || (c[3] == c[4] && c[4] == c[5]) || (c[6] == c[7] && c[7] == c[8]) || (c[0] == c[3] && c[3] == c[6]) || (c[1] == c[4] && c[4] == c[7]) || (c[2] == c[5] && c[5] == c[8]) || (c[0] == c[4] && c[4] == c[8]) || (c[2] == c[4] && c[4] == c[6]))
{
if (car == 'X')
{
fin = 1;
}
else
{
fin = 2;
}
}
if ( c[0] != '1' && c[1] != '2' && c[2] != '3' && c[3] != '4' && c[4] != '5' && c[5] != '6' && c[6] != '7' && c[7] != '8' && c[8] != '9' && fin !=1 && fin !=2 )
{
fin = 3;
}
return(fin);
}
int verif_case(char c[], int pos)
{
int res;
if ( (pos==1 && c[0]!='1') || (pos==2 && c[1]!='2') || (pos==3 && c[2]!='3') || (pos==4 && c[3]!='4') || (pos==5 && c[4]!='5') || (pos==6 && c[5]!='6') || (pos==7 && c[6]!='7') || (pos==8 && c[7]!='8') || (pos==9 && c[8]!='9') || pos > 9 || pos < 1 )
{
res=0;
}
else
{
res=1;
}
return(res);
}
int ia(char c[])
{
char pos, i, car = 'X', aleat;
pos = (rand() % (9 - 1 + 1)) + 1;
aleat = (rand() % (5 - 1 + 1)) + 1;
if (c[0] == '1' && aleat == 1)
{
pos = 1;
}
else if (c[0] != '1')
{
aleat = (rand() % (5 - 2 + 1)) + 1;
}
if (c[2] == '3' && aleat == 2)
{
pos = 3;
}
else if (c[2] != '3')
{
aleat = (rand() % (5 - 3 + 1)) + 1;
}
if (c[4] == '5' && aleat == 3)
{
pos = 5;
}
else if (c[4] != '5')
{
aleat = (rand() % (5 - 4 + 1)) + 1;
}
if (c[6] == '7' && aleat == 4)
{
pos = 7;
}
else if (c[5] != '7')
{
aleat = 5;
}
if (c[8] == '9' && aleat == 5)
{
pos = 9;
}
do {
/* lignes */
if (c[0] == car && c[1] == car && c[2] == '3')
{
pos = 3;
}
if (c[0] == car && c[2] == car && c[1] == '2')
{
pos = 2;
}
if (c[1] == car && c[2] == car && c[0] == '1')
{
pos = 1;
}
if (c[3] == car && c[4] == car && c[5] == '6')
{
pos = 6;
}
if (c[3] == car && c[5] == car && c[4] == '5')
{
pos = 5;
}
if (c[4] == car && c[5] == car && c[3] == '4')
{
pos = 4;
}
if (c[6] == car && c[7] == car && c[8] == '9')
{
pos = 9;
}
if (c[6] == car && c[8] == car && c[7] == '8')
{
pos = 8;
}
if (c[7] == car && c[8] == car && c[6] == '7')
{
pos = 7;
}
/* colonnes */
if (c[0] == car && c[3] == car && c[6] == '7')
{
pos = 7;
}
if (c[0] == car && c[6] == car && c[3] == '4')
{
pos = 4;
}
if (c[3] == car && c[6] == car && c[0] == '1')
{
pos = 1;
}
if (c[1] == car && c[4] == car && c[7] == '8')
{
pos = 8;
}
if (c[1] == car && c[7] == car && c[4] == '5')
{
pos = 5;
}
if (c[4] == car && c[7] == car && c[1] == '2')
{
pos = 2;
}
if (c[2] == car && c[5] == car && c[8] == '9')
{
pos = 9;
}
if (c[2] == car && c[8] == car && c[5] == '6')
{
pos = 6;
}
if (c[5] == car && c[8] == car && c[2] == '3')
{
pos = 3;
}
/* diagonales */
if (c[0] == car && c[4] == car && c[8] == '9')
{
pos = 9;
}
if (c[4] == car && c[8] == car && c[0] == '1')
{
pos = 1;
}
if (c[0] == car && c[8] == car && c[4] == '5')
{
pos = 5;
}
if (c[6] == car && c[4] == car && c[2] == '3')
{
pos = 3;
}
if (c[6] == car && c[2] == car && c[4] == '5')
{
pos = 5;
}
if (c[2] == car && c[4] == car && c[6] == '7')
{
pos = 7;
}
car = 'O';
i++;
} while (i<2);
return (pos);
}
Code windows :
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void Afficher(char c[]);
int verif_fin(char c[], char car);
int verif_case(char c[], int pos);
int ia(char c[]);
int main(void)
{
int end=1, win1=0, win2=0, win3=0, j, fin, pos, possible, choix=1;
char c[9], car;
do {
//system("clear");
system("cls");
printf("\n\t1 ou 2 joueurs ?\n");
scanf("%d", &choix);
} while (choix != 1 && choix != 2);
do {
c[0] = '1', c[1] = '2', c[2] = '3', c[3] = '4', c[4] = '5', c[5] = '6', c[6] = '7', c[7] = '8', c[8] = '9';
fin=0;
possible=1;
srand(time(NULL));
j = (rand() % (2 - 1 + 1)) + 1;
//system("clear");
system("cls");
Afficher(c);
do {
if (j == 1)
{
if (pos >=1 && pos <=9 && car == 'O' && choix == 1)
{
printf("\n(l'IA a joue en %d )\n", pos);
}
printf("\n Joueur 1 :\t");
scanf("%d", &pos);
j = 2;
car = 'X';
possible = verif_case(c, pos);
if (possible == 0 || pos > 9 || pos < 1)
{
do {
printf("\n Case deja remplie, ou mauvais chiffre entre. Veuillez recommencer :\t");
scanf("%d", &pos);
possible = verif_case(c, pos);
} while (possible == 0);
}
}
else
{
if (choix == 2)
{
printf("\n Joueur 2 :\t");
scanf("%d", &pos);
j = 1;
car = 'O';
possible = verif_case(c, pos);
if (possible == 0 || pos > 9 || pos < 1)
{
do {
printf("\n Case deja remplie, ou mauvais chiffre entre. Veuillez recommencer :\t");
scanf("%d", &pos);
possible = verif_case(c, pos);
} while (possible == 0);
}
}
else
{
pos = ia(c);
j = 1;
car = 'O';
possible = verif_case(c, pos);
if (possible == 0)
{
do {
pos = ia(c);
possible = verif_case(c, pos);
} while (possible == 0);
}
}
}
c[pos-1] = car;
//system("clear");
system("cls");
Afficher(c);
fin = verif_fin(c, car);
} while (fin == 0);
car = ' ';
if (fin == 3)
{
printf("\nMatch nul.\n");
win3++;
}
if (fin == 1)
{
printf("\nVous avez gagne.\n");
win1++;
}
if (fin == 2)
{
printf("\nVous avez perdu.\n");
win2++;
}
printf("\n\tRejouer ?\t1. Oui\n\t\t\t2. Non\t\t");
scanf("%d", &end);
} while (end == 1);
if (win1 > win2 && choix == 2)
{
printf("\nVictoire %d a %d du joueur 1 (%d match(s) nul(s)).\n\n", win2, win1, win3);
}
if (win1 > win2 && choix == 1)
{
printf("\nVous avez gagne %d a %d (%d match(s) nul(s)).\n\n", win1, win2, win3);
}
if (win1 == win2)
{
printf("\nEgalite %d partout (%d match(s) nul(s)).\n\n", win1, win3);
}
if (win1 < win2 && choix == 2)
{
printf("\nVictoire %d a %d du joueur 2 (%d match(s) nul(s)).\n\n", win2, win1, win3);
}
if (win1 < win2 && choix == 1)
{
printf("\nVictoire %d a %d de l'IA (%d match(s) nul(s)).\n\n", win2, win1, win3);
}
return 0;
}
////////////////////////////////////////////////////////////////
void Afficher(char c[])
{
printf("\n\t\t ___________");
printf("\n\t\t| | | |");
printf("\n\t\t| %c | %c | %c |", c[0], c[1], c[2]);
printf("\n\t\t|___|___|___|");
printf("\n\t\t| | | |");
printf("\n\t\t| %c | %c | %c |", c[3], c[4], c[5]);
printf("\n\t\t|___|___|___|");
printf("\n\t\t| | | |");
printf("\n\t\t| %c | %c | %c |", c[6], c[7], c[8]);
printf("\n\t\t|___|___|___|\n");
}
int verif_fin(char c[], char car)
{
int fin = 0;
if ( (c[0] == c[1] && c[1] == c[2]) || (c[3] == c[4] && c[4] == c[5]) || (c[6] == c[7] && c[7] == c[8]) || (c[0] == c[3] && c[3] == c[6]) || (c[1] == c[4] && c[4] == c[7]) || (c[2] == c[5] && c[5] == c[8]) || (c[0] == c[4] && c[4] == c[8]) || (c[2] == c[4] && c[4] == c[6]))
{
if (car == 'X')
{
fin = 1;
}
else
{
fin = 2;
}
}
if ( c[0] != '1' && c[1] != '2' && c[2] != '3' && c[3] != '4' && c[4] != '5' && c[5] != '6' && c[6] != '7' && c[7] != '8' && c[8] != '9' && fin !=1 && fin !=2 )
{
fin = 3;
}
return(fin);
}
int verif_case(char c[], int pos)
{
int res;
if ( (pos==1 && c[0]!='1') || (pos==2 && c[1]!='2') || (pos==3 && c[2]!='3') || (pos==4 && c[3]!='4') || (pos==5 && c[4]!='5') || (pos==6 && c[5]!='6') || (pos==7 && c[6]!='7') || (pos==8 && c[7]!='8') || (pos==9 && c[8]!='9') || pos > 9 || pos < 1 )
{
res=0;
}
else
{
res=1;
}
return(res);
}
int ia(char c[])
{
char pos, i, car = 'X', aleat;
pos = (rand() % (9 - 1 + 1)) + 1;
aleat = (rand() % (5 - 1 + 1)) + 1;
if (c[0] == '1' && aleat == 1)
{
pos = 1;
}
else if (c[0] != '1')
{
aleat = (rand() % (5 - 2 + 1)) + 1;
}
if (c[2] == '3' && aleat == 2)
{
pos = 3;
}
else if (c[2] != '3')
{
aleat = (rand() % (5 - 3 + 1)) + 1;
}
if (c[4] == '5' && aleat == 3)
{
pos = 5;
}
else if (c[4] != '5')
{
aleat = (rand() % (5 - 4 + 1)) + 1;
}
if (c[6] == '7' && aleat == 4)
{
pos = 7;
}
else if (c[5] != '7')
{
aleat = 5;
}
if (c[8] == '9' && aleat == 5)
{
pos = 9;
}
do {
/* lignes */
if (c[0] == car && c[1] == car && c[2] == '3')
{
pos = 3;
}
if (c[0] == car && c[2] == car && c[1] == '2')
{
pos = 2;
}
if (c[1] == car && c[2] == car && c[0] == '1')
{
pos = 1;
}
if (c[3] == car && c[4] == car && c[5] == '6')
{
pos = 6;
}
if (c[3] == car && c[5] == car && c[4] == '5')
{
pos = 5;
}
if (c[4] == car && c[5] == car && c[3] == '4')
{
pos = 4;
}
if (c[6] == car && c[7] == car && c[8] == '9')
{
pos = 9;
}
if (c[6] == car && c[8] == car && c[7] == '8')
{
pos = 8;
}
if (c[7] == car && c[8] == car && c[6] == '7')
{
pos = 7;
}
/* colonnes */
if (c[0] == car && c[3] == car && c[6] == '7')
{
pos = 7;
}
if (c[0] == car && c[6] == car && c[3] == '4')
{
pos = 4;
}
if (c[3] == car && c[6] == car && c[0] == '1')
{
pos = 1;
}
if (c[1] == car && c[4] == car && c[7] == '8')
{
pos = 8;
}
if (c[1] == car && c[7] == car && c[4] == '5')
{
pos = 5;
}
if (c[4] == car && c[7] == car && c[1] == '2')
{
pos = 2;
}
if (c[2] == car && c[5] == car && c[8] == '9')
{
pos = 9;
}
if (c[2] == car && c[8] == car && c[5] == '6')
{
pos = 6;
}
if (c[5] == car && c[8] == car && c[2] == '3')
{
pos = 3;
}
/* diagonales */
if (c[0] == car && c[4] == car && c[8] == '9')
{
pos = 9;
}
if (c[4] == car && c[8] == car && c[0] == '1')
{
pos = 1;
}
if (c[0] == car && c[8] == car && c[4] == '5')
{
pos = 5;
}
if (c[6] == car && c[4] == car && c[2] == '3')
{
pos = 3;
}
if (c[6] == car && c[2] == car && c[4] == '5')
{
pos = 5;
}
if (c[2] == car && c[4] == car && c[6] == '7')
{
pos = 7;
}
car = 'O';
i++;
} while (i<2);
return (pos);
}
Donc l'IA est simple : l'ordinateur analyse quatre possibilités. Par ordre de priorité :
- l'ia regarde si elle peut gagner dans ce coup. Si oui, alors elle joue dans la case correspondante.
- il y a un danger (c-a-d l'humain peut gagner au prochain coup), alors l'ia l'empêche de gagner en jouant dans la case en question.
- pas de danger, alors elle regarde si elle peut jouer dans un endroit "stratégique" : le milieu, ou les coins.
- sinon, alors l'ia joue dans une case libre au pif.
Bon, je sais, cette IA n'est pas très perfectionnée, vu qu'elle regarde juste le prochain coup, elle ne cherche pas à établir une stratégie sur le long terme, mais c'est un début, en attendant la seconde partie.
Et je sais, mon code dans la partie ia est assez indigeste, j'essairai d'alléger tout ça plus tard.
J'attends vos critiques/corrections/commentaires/suggestions !
L'IA est imbuvable !(niveau codage)
Par contre y a un petit soucis au niveau de ton IA:
Citation
- il y a un danger (c-a-d l'humain peut gagner au prochain coup), alors l'ia l'empêche de gagner en jouant dans la case en question.
- pas de danger, alors l'ia regarde si il peut gagner dans ce coup. Si oui, alors on joue dans la case correspondante.
- pas de danger, mais impossible de gagner en un coup. Alors l'ia joue dans une case libre au pif.
Mieux vaux qu'elle verifi si elle peut gagner puis après si elle est en danger car si elle gagne elle est plus en danger.
Il y a aussi un problème d'affichage avec l'IA si on joue plusieurs fois.
(PS: J'ai gagner 6 à 4) mais on peut faire mieux.
🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles- ♡ Copying is an act of love.
Les matchs nuls étaient gérés avant, mais sauf que la condition n'était jamais vérifiée (un || au lieu d'un && change tout...).
Sinon, pour l'exercice en lui même, si le joueur entre un choix invalide, on le fait rejouer, ou alors c'est tant pis pour lui et ça passe a joueur 2 ?
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int end_game(char tab[][3])
{
int i;
for(i=0;i<3;i++)/*On vérifie les lignes et les colonnes*/
{
if(tab[0][i] != '.' && tab[0][i] == tab[1][i] && tab[1][i] == tab[2][i])
{
printf("\nLe joueur %d a gagné", (tab[0][i]=='X')+1);
return 0;
}
else if(tab[i][0] != '.' && tab[i][0]==tab[i][1] && tab[i][1]==tab[i][2])
{
printf("\nLe joueur %d a gagné", (tab[i][0]=='X')+1);
return 0;
}
}
if(tab[0][0] != '.' && tab[0][0]==tab[1][1] && tab[1][1]==tab[2][2])/*On vérifie une diagonale*/
{
printf("\nLe joueur %d a gagné", (tab[1][1]=='X')+1);
return 0;
}
else if(tab[0][2] != '.' && tab[0][2]==tab[1][1] && tab[1][1]==tab[2][0])/*On vérifie l'autre*/
{
printf("\nLe joueur %d a gagné", (tab[1][3]=='X')+1);
return 0;
}
for(i=0;i<9;i++)/*On vérifie si il n'y a pas de match nul*/
{
if(tab[i/3][i%3]!='X' && tab[i/3][i%3]!='O')
return 1;
if(i==8)
printf("\nMatch nul !");
}
return 0;
}
void treat_input(char tab[][3], int entry, int player)
{
if(entry<9 && entry>=0)
{
if(tab[entry/3][entry%3]=='.')
{
if(player==1)
tab[entry/3][entry%3]='O';
else
tab[entry/3][entry%3]='X';
}
}
}
void display_tab(char tab[][3])
{
int i;
for(i=0;i<9;i++)
{
if(!(i%3))
printf("\n\n");
printf("%c ", tab[i/3][i%3]);
}
}
int game(void)
{
int entry=0, player=0;
char tab[3][3]={{'.', '.', '.'}, {'.', '.', '.'}, {'.', '.', '.'}};
srand(time(NULL));
player=rand()%2+1; /*détermine quel est le joueur qui joue le premier*/
printf("Au joueur %d de commencer\n", player);
display_tab(tab);
do
{
printf("\nJoueur %d : ", player);
scanf("%d", &entry);
entry--;/*On décrémente d'un pour faire correspondre l'entrée avec les indices du tableau*/
treat_input(tab, entry, player);
display_tab(tab);
player=(player)%2+1; /*on change le joueur*/
}while(end_game(tab));/*Tant que la partie n'est pas finie*/
return 0;
}
int main(void)
{
char c;
do
{
game();
while(getchar()!='\n');/*On vide le buffer*/
printf("Voulez vous rejouer ? (o/n) : ");
scanf("%c", &c);
}while(c!='n');
return 0;
}
Salut à tous,
Je suis nouveau sur le site et j'ai commencé à m'intéresser au C il y a environ 2 mois. Sans y passer mes journées j'essaye de progresser.
J'ai vous propose donc ma solution qui est loin d'être optimale. J'ai essayé de rendre le code clair même si je pense qu'il est un peu lourd.
#include <stdio.h>
#include <stdlib.h>
void affichage (int plateau [9]);
int saisie (void);
int testercoup(int plateau [9], int coup);
void jouercoup (int (*plateau)[9], int coup, int joueur);
int testergagnant(int plateau [9]);
int main(void)
{
int plateau [9] ;
int i;
int coup;
int compteur; /*utile pour déterminer quand la boucle doit s'arreter*/
int gagne;
int joueur;
int choix_fin;
/*on initialise le plateau*/
jeu : ;
compteur = 0;
for(i=0;i<9;i++)
{
plateau [i] = 0;
}
printf("Vous allez jouer au morpion ! \nVoici le jeu \n");
affichage(plateau);
/*boucle du jeu */
while(compteur<9)
{
printf("C'est au joueur 1 de jouer \n");
jeu1 : ;
coup = saisie();
if (testercoup(plateau,coup)==1)
{
jouercoup (&plateau, coup, 1);
}
else
{
printf("votre coup n'est pas valide, recommencez \n");
goto jeu1;
}
compteur++;
affichage(plateau);
gagne=testergagnant(plateau);
if (gagne==0)
{
printf("\nFIN \n");
goto fin;
}
printf("C'est au joueur 2 de jouer \n");
jeu2 : ;
coup = saisie();
if (testercoup(plateau,coup)==1)
{
jouercoup (&plateau, coup, 2);
}
else
{
printf("votre coup n'est pas valide, recommencez \n");
goto jeu2;
}
compteur++;
affichage(plateau);
gagne=testergagnant(plateau);
if (gagne==0)
{
printf("\nFIN \n");
goto fin;
}
}
fin : ;
printf("Pour rejouer rentrez 0, pour quitter rentrez 1\n");
scanf("%d",&choix_fin);
if (choix_fin == 0)
{
goto jeu;
}
else
{
return 0;
}
}
/*cette fonction prend le tableau représentant les cases, elle affiche un X si la case contient 1 (joueur 1),
O si elle contient 2 (joueur 2) et un . si elle contient 0 (case pas choisie) */
void affichage(int plateau [9])
{
int i;
int j;
int mat [3] [3];
/*on transforme le tableau en matrice*/
for(j=0;j<3;j++)
{
mat[0] [j] = plateau[j];
}
for(j=0;j<3;j++)
{
mat[1] [j] = plateau[j+3];
}
for(j=0;j<3;j++)
{
mat[2] [j] = plateau[j+6];
}
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
{
if (mat[i] [j]==0)
{
printf(". \t");
}
if (mat[i] [j]==1)
{
printf("X \t");
}
if (mat[i] [j]==2)
{
printf("O \t");
}
}
printf("\n \n");
}
}
/*elle afficher l'image du plateau*/
/*lit la saisie et la renvoie */
int saisie (void)
{
int choix;
int coup;
scanf("%d",&choix);
coup=choix;
return coup;
}
/*prend le plateau et la case jouée et renvoie 1 si c'est valide, 0 sinon*/
int testercoup(int plateau [9], int coup )
{
if (coup<=0 || coup>9)
{
return 0;
}
if (plateau[coup-1]== 1 || plateau[coup-1]==2 )
{
return 0;
}
return 1;
}
/*modifie le plateau avec la case jouée*/
void jouercoup (int (*plateau)[9], int coup, int joueur)
{
/*case jouée par le joueur 1*/
if (joueur==1)
{
(*plateau) [coup-1]=1;
}
else
{
(*plateau) [coup-1]=2;
}
/*le - vient du decalage d'indice*/
}
/*renvoie 0 si un des joueurs gagne ou s'il y a match nul, et 1 sinon */
int testergagnant(int plateau [9])
{
int i;
int j;
int Compteur ;
int mat [3] [3];
Compteur =0;
/*on transforme le tableau en matrice*/
for(j=0;j<3;j++)
{
mat[0] [j] = plateau[j];
}
for(j=0;j<3;j++)
{
mat[1] [j] = plateau[j+3];
}
for(j=0;j<3;j++)
{
mat[2] [j] = plateau[j+6];
}
for(i=0;i<3;i++)
{
/* on gagne avec une ligne*/
if(mat [i] [1]==1 && mat [i] [0]==1 && mat [i] [2]==1)
{
printf("Le joueur 1 a gagne \n");
return 0;
}
/*on gagne abec une colonne*/
if(mat [1] [i]==1 && mat [0] [i]==1 && mat [2] [i]==1)
{
printf("Le joueur 1 a gagne \n");
return 0;
}
}
/*on gagne avec une diagonale*/
if (mat[1][1]==1 && mat[0][0]==1 && mat[2][2]==1)
{
printf("Le joueur 1 a gagne \n");
return 0;
}
/*meme chose pour le joueur 2*/
for(i=0;i<3;i++)
{
/* on gagne avec une ligne*/
if(mat [i] [1]==2 && mat [i] [0]==2 && mat [i] [2]==2)
{
printf("Le joueur 2 a gagne \n");
return 0;
}
/*on gagne avec une colonne*/
if(mat [1] [i]==2 && mat [0] [i]==2 && mat [2] [i]==2)
{
printf("Le joueur 2 a gagne \n");
return 0;
}
}
/*on gagne avec une diagonale*/
if (mat[1][1]==2 && mat[0][0]==2 && mat[2][2]==2)
{
printf("Le joueur 2 a gagne \n");
return 0;
}
/*match nul*/
for (i=0;i<3;i++)
{
for (j=0;j<3;j++)
{
if (mat [i] [j]!=0)
{
Compteur ++; /*compte le nombre de case différentes de 0*/
}
}
}
if (Compteur==9)
{
printf("Match nul \n");
return 0;
}
return 1;
}
Bonne lecture ^^.
Et surtout n'hésitez pas à critiquer.
Merci d'avance.
void affichage (int plateau [9]);
int saisie (void);
int testercoup(int plateau [9], int coup);
void jouercoup (int (*plateau)[9], int coup, int joueur);
int testergagnant(int plateau [9]);
int main(void)
{
int plateau [9] ;
int i;
int coup;
int compteur; /*utile pour déterminer quand la boucle doit s'arreter*/
int gagne;
int joueur;
int choix_fin;
/*on initialise le plateau*/
/*cette fonction prend le tableau représentant les cases, elle affiche un X si la case contient 1 (joueur 1),
O si elle contient 2 (joueur 2) et un . si elle contient 0 (case pas choisie) */
void affichage(int plateau [9])
{
int i;
int j;
int mat [3] [3];
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
{
if (mat[i] [j]==0)
{
printf(". \t");
}
if (mat[i] [j]==1)
{
printf("X \t");
}
if (mat[i] [j]==2)
{
printf("O \t");
}
}
printf("\n \n");
}
}
/*elle afficher l'image du plateau*/
/*lit la saisie et la renvoie */
int saisie (void)
{
int choix;
int coup;
scanf("%d",&choix);
coup=choix;
return coup;
}
/*prend le plateau et la case jouée et renvoie 1 si c'est valide, 0 sinon*/
int testercoup(int plateau [9], int coup )
{
if (coup<=0 || coup>9)
{
return 0;
}
if (plateau[coup-1]== 1 || plateau[coup-1]==2 )
{
return 0;
}
return 1;
}
/*modifie le plateau avec la case jouée*/
void jouercoup (int (*plateau)[9], int coup, int joueur)
{
/*case jouée par le joueur 1*/
if (joueur==1)
{
(*plateau) [coup-1]=1;
}
else
{
(*plateau) [coup-1]=2;
}
/*le - vient du decalage d'indice*/
}
/*renvoie 0 si un des joueurs gagne ou s'il y a match nul, et 1 sinon */
int testergagnant(int plateau [9])
{
int i;
int j;
int Compteur ;
int mat [3] [3];
Compteur =0;
/*on transforme le tableau en matrice*/
for(j=0;j<3;j++)
{
mat[0] [j] = plateau[j];
}
for(j=0;j<3;j++)
{
mat[1] [j] = plateau[j+3];
}
for(j=0;j<3;j++)
{
mat[2] [j] = plateau[j+6];
}
for(i=0;i<3;i++)
{
/* on gagne avec une ligne*/
if(mat [i] [1]==1 && mat [i] [0]==1 && mat [i] [2]==1)
{
printf("Le joueur 1 a gagne \n");
return 0;
}
/*on gagne abec une colonne*/
if(mat [1] [i]==1 && mat [0] [i]==1 && mat [2] [i]==1)
{
printf("Le joueur 1 a gagne \n");
return 0;
}
}
/*on gagne avec une diagonale*/
if (mat[1][1]==1 && mat[0][0]==1 && mat[2][2]==1)
{
printf("Le joueur 1 a gagne \n");
return 0;
}
/*meme chose pour le joueur 2*/
for(i=0;i<3;i++)
{
/* on gagne avec une ligne*/
if(mat [i] [1]==2 && mat [i] [0]==2 && mat [i] [2]==2)
{
printf("Le joueur 2 a gagne \n");
return 0;
}
/*on gagne avec une colonne*/
if(mat [1] [i]==2 && mat [0] [i]==2 && mat [2] [i]==2)
{
printf("Le joueur 2 a gagne \n");
return 0;
}
}
/*on gagne avec une diagonale*/
if (mat[1][1]==2 && mat[0][0]==2 && mat[2][2]==2)
{
printf("Le joueur 2 a gagne \n");
return 0;
}
/*match nul*/
for (i=0;i<3;i++)
{
for (j=0;j<3;j++)
{
if (mat [i] [j]!=0)
{
Compteur ++; /*compte le nombre de case différentes de 0*/
}
}
}
if (Compteur==9)
{
printf("Match nul \n");
return 0;
}
return 1;
}
</code>
Si ça ne fais que 2 mois que tu fais de la programmation évite les goto. Préfère les fonctions.
Je comprend pas le prototype de la fonction voidjouercoup(int(*plateau)[9],intcoup,intjoueur)
Cela montre que tu as compris l'interes des pointeurs, c'est bien, mais que tu n'as pas encore bien compris les tableaux.
Tu peux directement faire :
void jouercoup (int plateau[9], int coup, int joueur)
{
/*case jouée par le joueur 1*/
if (joueur==1)
{
plateau[coup-1]=1;
}
else
{
plateau[coup-1]=2;
}
/*le - vient du decalage d'indice*/
}
🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles- ♡ Copying is an act of love.
Je sais pas. Ca me paraît un peu bizarre. Parce que si je lui passe pas un pointeur sur le tableau il ne va pas me modifier mon tableau.
Je vais essayer pour voir.
void jouercoup (int plateau[9], int coup, int joueur)
par exemple, même si ce n'est pas la manière la plus commune.
Les tableaux sont convertis en pointeur vers leur premier élément lors du passage à une fonction, donc, les prototypes:
void jouercoup (int plateau[9], int coup, int joueur); /* inutile */
void jouercoup (int plateau[], int coup, int joueur);
void jouercoup (int *plateau, int coup, int joueur);
sont identiques.
Citation : kiffman
Je sais pas. Ca me paraît un peu bizarre. Parce que si je lui passe pas un pointeur sur le tableau il ne va pas me modifier mon tableau.
Ce n'est pas le pointeur sur ton tableau que tu pourras modifier, mais le tableau en lui-même.
@moliplate : Non, tu n'as pas pris en compte tout ce que je t'ai dis.
@th-p :
Tu peux faire plus simple pour initialiser ton tableau (strncpy).
Tu appelles srand à chaque tour de boucle.
j = (rand() % (2 - 1 + 1)) + 1; => Tu es sûr que faire 2 - 1 + 1 est super ?
system("clear"); on s'en fou
if (pos >=1 && pos <=9 && car == 'O' && choix == 1) => Au premier passage de la boucle, tes variables car et pos ne sont pas initialisées
Tu pourrais améliorer ta saisie pour éviter les répétitions
Tu pourrais créer une fonction pour ta saisie
Tu fais 2 fois la même chose pour joueur 1 et joueur 2, tu peux réduire
L'IA n'est pas le but de l'exercice donc je ne l'ai pas reagardé, mais à vue de nez comme ça tu peux largement réduire ta fonction
Tu pourrais utiliser un tableau plut^lot qu'utiliser les variables win1-2-3
Tu pourrais faire une fonction et simplifier tes conditions qui disent qui a gagner et combien de fois
Dans ta fonction verif_fin tu pourrais faire un else if pour enlever la condition && fin !=1 && fin !=2
Dans ta fonction verif_case tu peux faire un accès direct au tableau
Tu as fait 2 codes, 1 pour win et l'autre pour *nix, le préprocesseur te serait d'une grande aide pour éviter ça
@baki :
Tu fais appel à la fonction srand à chaque fois que tu fais une nouvelle partie
Tu pourrais faire en sorte que l'utilisateur ne joue pas 2 fois au même endroit ; càd que si je joue la même case que ce soit le même joueur qui rejoue pas le joueur suivant
}while(end_game(tab));/*Tant que la partie n'est pas finie*/ => Hmm, tu pourrais choisir un autre nom pour ta fonction ou alors faire !end_game, ce n'est pas cohérent : tant que c'est la fin du jeu on boucle
@kiffman :
Ta variable joueur n'est pas utilisée
Les goto ne sont pas très appréciés en C, tu peux les enlever très facilement. D'ailleurs, tous tes points virgule après les ':' sont inutiles
Tu peux améliorer ta fonction affichage, tu n'as pas besoin de convertir ton tableau, un simple if sur le tableau d'origine suffit
Dans ta fonction saisie, pourquoi tu utilises une 2ème variable ? tu peux simplement retourner la première
Tu fais 2 fois la même chose pour joueur 1 et 2, tu peux simplifier
Pourquoi envoyer un pointeur sur plateau a ta fonction jouercoup ? le tableau en lui-même suffit
Tu n'as pas besoin de faire de if...else dans cette même fonction, une simple affectation suffit
Tu fais plein de répétitions dans ta fonction testergagnant tu peux simplifier
Pour tout ceux qui ont fait le morpion en console, je vous invite à venir nous rejoindre pour le faire en graphique (avec SDL ou autre) : http://www.siteduzero.com/forum-83-594 [...] morp-sdl.html
C'est à ce moment que vous verrez si votre programme est bien découpé. Si vous regardez mon code, j'ai eu juste à modifier les fonctions d'affichage et de saisie. Tout le reste du jeu (le fond) n'a pas bougé d'un poil.
Bonjour à vous tous, je pense que c'est un peu tard, mais avant de participer a la version SDL, je voudrais savoir ce que vous pensiez de mon code, et surtout si vous trouvez des erreurs(warning, segfault, erreur dans le jeu).
J'ai essayer de faire en sorte que tout sois paramètrable, longueur largeur, et nombre de pion a aligné, normalement ça marche, mais bon, on est jamais a l'abri, voici la bête
Sans avoir regardé le code, juste le début, je te dis que l'utilisation que tu fais des macros est justement celle qu'il ne faut pas faire.
Fais une fonction ou mets ça en dur dans ton code.
Je regarderai ton code plus tard.
Pour la série de typedef qui suit, tu as voulu singer les types de la SDL, j'imagine en prévision.
Mais, le type int suffit dans tout les cas, et tu t'obliges à faire des casts, nombreux, non nécessaires, laids.
Pour l'utilisation d'un tableau dynamique, soit.
En gros, tu es dans l'éxcès, on y est tous passé.
Tu commences à maîtriser certaines constructions du C, et tu en abuses(on l'a tous fait... ).
Mais à coté, reste des choses étranges
printf("\n");
Un bazooka, pour tuer une mouche...
Grid *grid = (Grid*) my_malloc(sizeof *grid);
Bon, d'accord, tu aimes les casts...
Aussi, cette manie de déclarer les fonctions systématiquement avant le main, je n'aime pas.
Si tu définis les fonctions dans le bon ordre, ce n'est pas utile(ça alourdit...)
Après, les bons points:
-L'utilisation d'un tableau 1d est très naturelle, je trouve.
-...
Après, je n'ai pas testé.
Je pense que tu devrais faire plus simple, naturel, en fait...
Pour Pouet et Gurney, Okay pour les macros, mais j'aimerais tout de même savoir pourquoi ^^(Car cela ne marche que si on a une variable x, y, et numCase??)
Citation : GurneyH
Pour la série de typedef qui suit, tu as voulu singer les types de la SDL, j'imagine en prévision.
Mais, le type int suffit dans tout les cas, et tu t'obliges à faire des casts, nombreux, non nécessaires, laids.
En effet, c'est pour la dîtes SDL ^^. Je trouve cela plus juste d'utiliser celon moi les unsigneds et les signeds
Citation : GurneyH
Aussi, cette manie de déclarer les fonctions systématiquement avant le main, je n'aime pas.
Si tu définis les fonctions dans le bon ordre, ce n'est pas utile(ça alourdit...)
La, je dois avouer ne pas t'avoir compris. Il ne faut pas je mette mes fonctions l'ordre? Ou il faut je les mette?
Ensuite, pour le printf, effectivement, il est peut être plus adapter d'utiliser putchar() ^^.
Pour le cast des mallocs, celà m'aide a m'éviter quelques bugs(ici inutile soit), je me sers de la petite astuce de "Uknow", cela permet de bien se reconnaitre le bon pointeur, une étoile de différence ^^.
Cordialement
http://cpp-rendering.io : Vous trouverez tout ce dont vous avez besoin sur Vulkan / OpenGL et le rendu 3D !
En effet, c'est pour la dîtes SDL ^^. Je trouve cela plus juste d'utiliser celon moi les unsigneds et les signeds
Jamais!
Tu vas être etre emmener en faisant cela, à mélangé les signed et unsigned, et c'est juste une source de bordel.
Utilises le type int, point...
Citation : qnope
Ensuite, pour le printf, effectivement, il est peut être plus adapter d'utiliser putchar() ^^.
ou
puts("");
Citation : qnope
Pour le cast des mallocs, celà m'aide a m'éviter quelques bugs(ici inutile soit)
Non, ça sert juste à en créer, si tu compiles bien en C...
Genre, tu n'inclues pas <stdlib.h>, ta fonction retourne un entier, et, avec ton cast, tu fais taire le compilateur...
edit:
Citation : qnope
La, je dois avouer ne pas t'avoir compris. Il ne faut pas je mette mes fonctions l'ordre? Ou il faut je les mette?
C'est la déclaration qui est inutile...
Si tes fonctions sont dans le bon ordre, et que tu ne fais pas de récursivité croisée...
qnope >
Pourquoi tu redéfinis size_t ? les headers standard ne te suffisent pas ? de plus, tu forces le type à unsigned int, chez moi c'est pas un int.
L'utilisation de malloc et cie n'est pas nécessaire, des tableaux statiques auraient suffit
Les casts malloc sont inutiles
Je pense que tu peux faire mieux qu'une boucle infinie dans ta fonction 'play'
Pourquoi tu utilises 2 tableaux ? tu pourrais n'en utiliser qu'un seul
Les commentaires sont inutiles, ils doivent servir à éclaircir le code, pas l'alourdir
Dans ta fonction test_Case, tu ne vérifies pas si la case entrée est bien dans le tableau
Tu fais trop de cast inutiles
Pourquoi tu ne donnes pas à ta variable 'player' la valeur J1 ou J2 en fonction du joueur ? ça t'éviterais les ternaires abusifs
Dans ta fonction end_Play, ton break te fait sortir de la boucle la plus imbriquée, pas la première
Donc je n'ai pas compris exactement ce que tu as voulu dire ^^, je suis en train de modifier mes casts etc, je regarderais dans mon code ce que tu as voulu dire exactement
EDIT : c'est bon j'ai compris
Voilà le nouveau code
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
typedef unsigned char bool;
enum{false, true};
enum{J1 = -1, J2 = -2};
typedef struct
{
int *grid;
int width, height, align;
}Grid;
void *my_malloc(size_t n);/*Malloc verificate*/
void my_scanf(int *place, char const *print);/*Scanf checked*/
Grid *create_Grid(unsigned width, unsigned height, unsigned align);
void delete_Grid(Grid *(*grid));
void print_Grid(Grid *grid);
void play(Grid *grid);
bool test_Case(Grid *grid, int numCase);
bool win(Grid *grid, int numCase, int player);
bool end_Play(Grid *grid);
void my_scanf(int *place, char const *print)
{
int c;
do
{
printf("%s", print);
c = scanf("%d", place);
while(getchar() != '\n');
}while (c != 1);
}
void *my_malloc(size_t n)
{
void *p;
if((p = malloc(n)) == NULL)
fprintf(stderr, "Erreur sur le malloc"), exit(1);
return p;
}
Grid *create_Grid(unsigned width, unsigned height, unsigned align)
{
unsigned x, y;
int n = 0;
Grid *grid = my_malloc(sizeof *grid);
grid->grid = my_malloc(sizeof *(grid->grid) * width * height);
grid->width = (int) width;
grid->height = (int) height;
grid->align = (int) align;
for(y = 0; y < height; y++)
for(x = 0; x < width; x++)
grid->grid[y * width + x] = ++n;
return grid;
}
void delete_Grid(Grid *(*grid))
{
free((*grid)->grid);
free(*grid);
*grid = NULL;
}
void print_Grid(Grid *grid)
{
int x, y;
for(y = 0; y < grid->height; y++)
{
for(x = 0; x < grid->width; x++)
printf("___");
putchar('\n');
for(x = 0; x < grid->width; x++)
{
if(grid->grid[y * grid->width + x] > 0)
printf("%2d|", grid->grid[y * grid->width + x]);
else
printf("%2c|", (grid->grid[y * grid->width + x] == J1)
? 'X' : 'O');
}
putchar('\n');
}
}
bool win(Grid *grid, int numCase, int player)
{
int xMin, xMax, yMin, yMax, x, y, xBase, yBase,
n = 0;
x = numCase % grid->width;
y = numCase / grid->width;
xMin = (x - grid->align + 1);
xMax = (x + grid->align);
yMin = (y - grid->align + 1);
yMax = (y + grid->align);
if(xMin < 0)
xMin = 0;
if(yMin < 0)
yMin = 0;
if(xMax >= grid->width)
xMax = grid->width;
if(yMax >= grid->height)
yMax = grid->height;
xBase = x;
yBase = y;
for(x = xMin; x < xMax; x++)
{
if(grid->grid[y * grid->width + x] == player)
n++;
else
n = 0;
if(n == grid->align)
return true;
}/*Line*/
x = xBase;
n = 0;
for(y = yMin; y < yMax; y++)
{
if(grid->grid[y * grid->width + x] == player)
n++;
else
n = 0;
if(n == grid->align)
return true;
}/*Col*/
x = xMin;
n = 0;
for(y = yMin; y < yMax; y++)
{
if(grid->grid[y * grid->width + x] == player)
n++;
else
n = 0;
if(n == grid->align)
return true;
x++;
if(x >= grid->width)
x = xMax - 1;
}/*left right*/
x = xMax - 1;
n = 0;
for(y = yMin; y < yMax; y++)
{
if(grid->grid[y * grid->width + x] == player)
n++;
else
n = 0;
if(n == grid->align)
return true;
x--;
if(x < 0)
x = xMin;
}/*right left*/
return false;/*Else not win, return 0;*/
}
void play(Grid *grid)
{
int numCase;
int player = J1;
int x, y;
while(1)
{
print_Grid(grid);
printf("\nA vous de jouez joueur %d\n", -player);
do
{
my_scanf(&numCase, "Entrez le numero de case :\n");
}while(test_Case(grid, numCase) == false);
numCase--;
x = numCase % grid->width;
y = numCase / grid->width;
grid->grid[y * grid->width + x] = player;
if(win(grid, numCase, player) == true)
{
print_Grid(grid);
printf("\nLe joueur %d a gagner\n", -player);
break;
}
if(end_Play(grid) == true)
{
print_Grid(grid);
printf("\nIl y a match nul\n");
break;
}
if(player == J1)
player = J2;
else
player = J1;
}
}
bool test_Case(Grid *grid, int numCase)
{
int x, y;
numCase--;
x = numCase % grid->width;
y = numCase / grid->width;
if(x < 0 || x >= grid->width || y < 0 || y >= grid->height)
return false;
return (grid->grid[y * grid->width + x] > 0);
}
bool end_Play(Grid *grid)
{
bool end = true;
int x, y;
for(y = 0; y < grid->height; y++)
{
for(x = 0; x < grid->width; x++)
{
if(grid->grid[y * grid->width + x] > 0)
{
end = false;
return end;
}
}
}
return end;
}
int main(void)
{
Grid *grid = create_Grid(3, 3, 3);
play(grid);
delete_Grid(&grid);
return 0;
}
Merci
http://cpp-rendering.io : Vous trouverez tout ce dont vous avez besoin sur Vulkan / OpenGL et le rendu 3D !
#include <stdio.h>
#include <stdlib.h>
void affichage(char* tableau);
int saisie(int joueur);
int testerCoup(int coord, char* tableau); // Si le coup est bon, il renvoie 1
void jouerCoup(char* tableau, int coord, int joueur);
void gagner(char* tableau, int* gagne);
int main(void)
{
char jouer = 'O';
while (jouer != 'N')
{
int coord = 0;
int i = 0;
int gagne = 0;
char tableau[10];
int joueur = 1; //1 : joueur 1, 2 : joueur 2
//Initialisation de toutes les cellules du tableau avec un point (.)
for (i = 0 ; i <= 8 ; i++)
{
tableau[i] = '.';
}
while (!gagne)
{
//Affichage du tableau
affichage (tableau);
//Saisie des coordonnées et tester si le coup est permis
while(testerCoup(coord, tableau) == 0)
coord = saisie(joueur);
//On inscrit le coup dans le tableau
jouerCoup(tableau, coord, joueur);
//On change de joueur
if (joueur == 1)
joueur++;
else if (joueur == 2)
joueur--;
//Un joueur a gagné ?
gagner(tableau, &gagne);
}
printf("\n\nRejouer ? (O/N)\n");
scanf("%c", &jouer);
}
return 0;
}
void affichage(char* tableau)
{
printf("\n ___ ___ ___\n");
printf("| %c | %c | %c |\n", tableau[0], tableau[1], tableau[2]);
printf(" ___ ___ ___\n");
printf("| %c | %c | %c |\n", tableau[3], tableau[4], tableau[5]);
printf(" ___ ___ ___\n");
printf("| %c | %c | %c |\n", tableau[6], tableau[7], tableau[8]);
printf(" ___ ___ ___\n\n");
}
int saisie(int joueur)
{
int coord2 = 0;
printf("\n\nJoueur n° %d : ", joueur);
scanf("%d", &coord2);
return coord2;
}
void gagner(char* tableau, int* gagne)
{
if (tableau[0] == 'X' && tableau[1] == 'X' && tableau[2] == 'X')
{
printf("Joueur 1, vous avez gagné !!");
*gagne = 1;
}
else if (tableau[3] == 'X' && tableau[4] == 'X' && tableau[5] == 'X')
{
printf("Joueur 1, vous avez gagné !!");
*gagne = 1;
}
else if (tableau[6] == 'X' && tableau[7] == 'X' && tableau[8] == 'X')
{
printf("Joueur 1, vous avez gagné !!");
*gagne = 1;
}
else if (tableau[0] == 'X' && tableau[3] == 'X' && tableau[6] == 'X')
{
printf("Joueur 1, vous avez gagné !!");
*gagne = 1;
}
else if (tableau[1] == 'X' && tableau[4] == 'X' && tableau[7] == 'X')
{
printf("Joueur 1, vous avez gagné !!");
*gagne = 1;
}
else if (tableau[2] == 'X' && tableau[5] == 'X' && tableau[8] == 'X')
{
printf("Joueur 1, vous avez gagné !!");
*gagne = 1;
}
else if (tableau[0] == 'X' && tableau[4] == 'X' && tableau[8] == 'X')
{
printf("Joueur 1, vous avez gagné !!");
*gagne = 1;
}
else if (tableau[2] == 'X' && tableau[4] == 'X' && tableau[6] == 'X')
{
printf("Joueur 1, vous avez gagné !!");
*gagne = 1;
}
else if (tableau[0] == 'O' && tableau[1] == 'O' && tableau[2] == 'O')
{
printf("Joueur 2, vous avez gagné !!");
*gagne = 1;
}
else if (tableau[3] == 'O' && tableau[4] == 'O' && tableau[5] == 'O')
{
printf("Joueur 2, vous avez gagné !!");
*gagne = 1;
}
else if (tableau[6] == 'O' && tableau[7] == 'O' && tableau[8] == 'O')
{
printf("Joueur 2, vous avez gagné !!");
*gagne = 1;
}
else if (tableau[0] == 'O' && tableau[3] == 'O' && tableau[6] == 'O')
{
printf("Joueur 2, vous avez gagné !!");
*gagne = 1;
}
else if (tableau[1] == 'O' && tableau[4] == 'O' && tableau[7] == 'O')
{
printf("Joueur 2, vous avez gagné !!");
*gagne = 1;
}
else if (tableau[2] == 'O' && tableau[5] == 'O' && tableau[8] == 'O')
{
printf("Joueur 2, vous avez gagné !!");
*gagne = 1;
}
else if (tableau[0] == 'O' && tableau[4] == 'O' && tableau[8] == 'O' )
{
printf("Joueur 2, vous avez gagné !!");
*gagne = 1;
}
else if (tableau[2] == 'O' && tableau[4] == 'O' && tableau[6] == 'O')
{
printf("Joueur 2, vous avez gagné !!");
*gagne = 1;
}
else
*gagne = 0;
}
int testerCoup(int coord, char* tableau)
{
if (tableau[coord-1] != '.')
return 0;
else
return 1;
}
void jouerCoup(char* tableau, int coord, int joueur)
{
if (joueur == 1)
{
tableau[coord-1] = 'X';
}
else if (joueur == 2)
{
tableau[coord-1] = 'O';
}
}
Alors il y a une seule chose qui ne fonctionne pas : c'est que le scanf à la ligne n° 49 ne veux pas être executé : il ne me demande rien à entrer. Du coup, je ne peux pas indiquer si je veux rejouer ou non, et le programme continuer de tourner.
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles - ♡ Copying is an act of love.
🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles - ♡ Copying is an act of love.
🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles - ♡ Copying is an act of love.