```c
#include <stdio.h>
```
Cette ligne est une directive du préprocesseur qui indique d'inclure la
bibliothèque standard d'entrée/sortie du langage C.
```c
void tour_joueur1(void);
void tour_joueur2(void);
int conditions_victoire(void);
void affichage(void);
void reinitialiser(void);
```
Ces lignes déclarent les prototypes des fonctions utilisées dans le code.
```c
char grille[9];
int choix;
int win;
int tours_joues;
```
Ces lignes déclarent des variables globales utilisées dans le code. La variable
`grille` est un tableau de caractères de taille 9 qui représente la grille du jeu.
`choix` est la variable pour stocker le choix du joueur. `win` est une variable
booléenne qui est utilisée pour vérifier si un joueur a gagné. `tours_joues`
indique le nombre de tours joués.
;;;;;;;;;;c
int main()
{
printf("----------------\n");
printf("Jeu du Morpion !\n");
printf("----------------\n");
;;;;;;
Ceci est la fonction principale `main()`. Les instructions de cette partie du code
affichent simplement le titre du jeu.
```c
printf("Les numeros sur la droite de la grille correspondent aux valeurs à
entrer pour cocher la case desiree :D\n");
```
Cette ligne explique aux joueurs comment entrer le numéro de case pour cocher la
case désirée.
```c
do
{
reinitialiser();
affichage();
win = 0;
tours_joues = 0;
```
Cette partie est la boucle principale du jeu. Elle est exécutée tant que le joueur
choisit de rejouer. À chaque itération de la boucle, la grille est réinitialisée et
le nombre de victoires, de tours joués sont réinitialisés.
```c
do
{
tour_joueur1();
affichage();
tours_joues++;
```
Cette partie est la boucle pour le tour du joueur 1. Le joueur 1 choisit une case,
puis la grille et le nombre de tours joués sont mis à jour.
```c
if (conditions_victoire() == 1)
{
printf("Joueur 1 a gagne !\n");
break;
}
else if (tours_joues == 9)
{
printf("Match nul !\n");
break;
}
```
Après chaque tour, le code vérifie si le joueur 1 a gagné ou s'il y a un match nul.
Si l'une de ces conditions est vérifiée, un message approprié est affiché et la
boucle interne est interrompue.
```c
tour_joueur2();
affichage();
tours_joues++;
if (conditions_victoire() == 1)
{
printf("Joueur 2 a gagne !\n");
break;
}
else if (tours_joues == 9)
{
printf("Match nul !\n");
break;
}
} while (1);
```
Cette partie est similaire à la boucle précédente, mais pour le tour du joueur 2.
```c
printf("Voulez-vous rejouer ? (1 pour oui, 0 pour non)\n");
scanf("%d", &choix);
} while (choix == 1);
```
Une fois que le jeu est terminé, les joueurs sont invités à choisir s'ils veulent
rejouer. Si `choix` est égal à 1, la boucle externe est répétée et le jeu
recommence. Sinon, le programme se termine.
```c
printf("Merci d'avoir joue !\n");
return 0;
}
```
```c
void affichage(void)
{
printf("\n\n\n");
printf("|%c|%c|%c| 0 1 2\n", grille[0], grille[1], grille[2]);
printf("-------\n");
printf("|%c|%c|%c| 3 4 5\n", grille[3], grille[4], grille[5]);
printf("-------\n");
printf("|%c|%c|%c| 6 7 8\n", grille[6], grille[7], grille[8]);
printf("\n\n\n");
}
```
Cette fonction `affichage` est utilisée pour afficher l'état de la grille de jeu.
La grille est affichée sous forme de tableau avec des indices pour chaque cellule.
Cela aide les joueurs à identifier les cellules par leur numéro lorsqu'ils
sélectionnent leur coup.
```c
void reinitialiser(void)
{
for (int i = 0; i < 9; i++)
{
grille[i] = ' ';
}
}
```
La fonction `reinitialiser` est utilisée pour réinitialiser la grille de jeu en
remplaçant tous les caractères des cellules par des espaces vides.
```c
int conditions_victoire(void)
{
if ((grille[0] == grille[1] && grille[0] == grille[2] && grille[0] != ' ') &&
(grille[3] == grille[4] && grille[3] == grille[5] && grille[3] != ' ') &&
(grille[6] == grille[7] && grille[6] == grille[8] && grille[6] != ' ') &&
(grille[0] == grille[3] && grille[0] == grille[6] && grille[0] != ' ') &&
(grille[1] == grille[4] && grille[1] == grille[7] && grille[1] != ' ') &&
(grille[2] == grille[5] && grille[2] == grille[8] && grille[2] != ' ') &&
(grille[0] == grille[4] && grille[0] == grille[8] && grille[0] != ' ') ||
(grille[2] == grille[4] && grille[2] == grille[6] && grille[2] != ' '))
{
return 1;
}
return 0;
}
```
La fonction `conditions_victoire` vérifie s'il y a une condition de victoire dans
le jeu du morpion. Elle vérifie si les cellules de la grille contiennent des
symboles identiques (`'X'` ou `'O'`) dans les positions gagnantes du morpion. Si
une condition de victoire est remplie, la fonction retourne `1`, sinon elle
retourne `0`.
```c
void tour_joueur1(void)
{
do
{
printf("Joueur 1, veuillez entrer le numero de la case desiree :\n");
scanf("%d", &choix);
if (grille[choix] == ' ')
{
grille[choix] = 'O';
break;
}
else
{
printf("Case déjà occupée !\n");
}
} while (1);
}
```
La fonction `tour_joueur1` permet au joueur 1 de sélectionner une cellule pour
placer son symbole "O". Elle demande au joueur de saisir un numéro de cellule, puis
vérifie si la cellule est libre. Si c'est le cas, le symbole "O" est placé dans la
cellule correspondante de la grille. Si la cellule est déjà occupée, un message
d'erreur est affiché et le joueur est invité à saisir un autre numéro de cellule.
```c
void tour_joueur2(void)
{
do
{
printf("Joueur 2, veuillez entrer le numero de la case desiree :\n");
scanf("%d", &choix);
if (grille[choix] == ' ')
{
grille[choix] = 'X';
break;
}
else
{
printf("Case déjà occupée !\n");
}
} while (1);
}
```
La fonction `tour_joueur2` a le même fonctionnement que `tour_joueur1`, mais cette
fois c'est le joueur 2 qui sélectionne une cellule pour placer son symbole "X".
Ces fonctions peuvent être utilisées ensemble dans un programme principal pour
mettre en œuvre le jeu du morpion, en alternant les tours des joueurs et en
affichant l'état de la grille après chaque coup.
