Création jeu XO en C++

La création d’un jeu de XO (ou morpion) en utilisant le langage de programmation C++ implique plusieurs étapes, de la conception initiale à la mise en œuvre du code. Le XO est un jeu de société classique pour deux joueurs, se déroulant sur une grille de 3×3 cases. Chaque joueur utilise un symbole, soit « X » ou « O, et l’objectif est d’aligner trois de ses symboles horizontalement, verticalement ou en diagonale. Voici un guide détaillé pour la réalisation de ce projet.

Conception du jeu :

Avant de plonger dans le code, il est essentiel de concevoir le jeu. On peut utiliser un tableau bidimensionnel de caractères pour représenter la grille du XO. Chaque cellule de la grille peut contenir un espace, « X » ou « O ». On peut également définir une structure pour représenter les joueurs, avec un attribut pour le symbole.

cppCopy code
#include 
using namespace std;

// Structure pour représenter un joueur
struct Joueur {
    char symbole;
};

// Fonction pour initialiser la grille avec des espaces
void initialiserGrille(char grille[3][3]) {
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            grille[i][j] = ' ';
        }
    }
}

// Fonction pour afficher la grille
void afficherGrille(char grille[3][3]) {
    cout << "  0 1 2" << endl;
    for (int i = 0; i < 3; i++) {
        cout << i << " ";
        for (int j = 0; j < 3; j++) {
            cout << grille[i][j] << " ";
        }
        cout << endl;
    }
}

// Fonction pour vérifier si la case est vide
bool estCaseVide(char grille[3][3], int ligne, int colonne) {
    return grille[ligne][colonne] == ' ';
}

// Fonction pour vérifier si un joueur a gagné
bool aGagne(char grille[3][3], Joueur joueur) {
    // Vérification des lignes et colonnes
    for (int i = 0; i < 3; i++) {
        if (grille[i][0] == joueur.symbole && grille[i][1] == joueur.symbole && grille[i][2] == joueur.symbole)
            return true;
        if (grille[0][i] == joueur.symbole && grille[1][i] == joueur.symbole && grille[2][i] == joueur.symbole)
            return true;
    }

    // Vérification des diagonales
    if (grille[0][0] == joueur.symbole && grille[1][1] == joueur.symbole && grille[2][2] == joueur.symbole)
        return true;
    if (grille[0][2] == joueur.symbole && grille[1][1] == joueur.symbole && grille[2][0] == joueur.symbole)
        return true;

    return false;
}

// Fonction principale
int main() {
    char grille[3][3];
    initialiserGrille(grille);

    Joueur joueur1, joueur2;
    joueur1.symbole = 'X';
    joueur2.symbole = 'O';

    Joueur joueurActuel = joueur1; // Le joueur qui commence est joueur1

    int ligne, colonne;

    // Boucle de jeu
    for (int tour = 0; tour < 9; tour++) {
        afficherGrille(grille);

        // Saisie des coordonnées par le joueur
        cout << "Tour du Joueur " << joueurActuel.symbole << endl;
        cout << "Entrez la ligne et la colonne (séparées par un espace) : ";
        cin >> ligne >> colonne;

        // Vérification de la validité de la case
        while (ligne < 0 || ligne >= 3 || colonne < 0 || colonne >= 3 || !estCaseVide(grille, ligne, colonne)) {
            cout << "Case invalide. Réessayez : ";
            cin >> ligne >> colonne;
        }

        // Remplissage de la case
        grille[ligne][colonne] = joueurActuel.symbole;

        // Vérification de la victoire
        if (aGagne(grille, joueurActuel)) {
            afficherGrille(grille);
            cout << "Le Joueur " << joueurActuel.symbole << " a gagné !" << endl;
            break;
        }

        // Changer de joueur pour le prochain tour
        joueurActuel = (joueurActuel == joueur1) ? joueur2 : joueur1;
    }

    // Si la boucle se termine sans vainqueur
    if (aGagne(grille, joueur1) || aGagne(grille, joueur2)) {
        cout << "Match nul !" << endl;
    }

    return 0;
}

Ce programme en C++ crée une version console du jeu XO. Il utilise une grille de 3×3, permet à deux joueurs de s’alternet, vérifie la validité des coups et détermine le vainqueur. La structure du code permet une bonne lisibilité et maintenabilité. Vous pouvez également étendre le code pour inclure des fonctionnalités supplémentaires, telles que la gestion des noms des joueurs, le suivi des statistiques, etc. N’hésitez pas à explorer et à personnaliser le code en fonction de vos besoins.

La conception et la réalisation d’un jeu de XO en C++ peuvent être étendues pour inclure des fonctionnalités plus avancées, améliorer l’expérience utilisateur et rendre le code plus modulaire. Voici quelques suggestions pour enrichir davantage le programme :

1. Gestion des Noms des Joueurs :

Ajoutez la possibilité pour les joueurs d’entrer leurs noms au début du jeu. Modifiez la structure du joueur pour inclure le nom.

cppCopy code
struct Joueur {
    char symbole;
    string nom;
};

Modifiez ensuite le code principal pour permettre la saisie des noms.

cppCopy code
// Dans la fonction main
cout << "Entrez le nom du Joueur 1 : ";
cin >> joueur1.nom;
cout << "Entrez le nom du Joueur 2 : ";
cin >> joueur2.nom;

2. Affichage des Coordonnées :

Améliorez l’affichage en incluant les coordonnées des cellules pour aider les joueurs à choisir leur coup.

cppCopy code
// Dans la fonction afficherGrille
cout << "  0 1 2" << endl;
for (int i = 0; i < 3; i++) {
    cout << i << " ";
    for (int j = 0; j < 3; j++) {
        cout << grille[i][j] << " ";
    }
    cout << endl;
}

3. Validation des Entrées :

Ajoutez une fonction de validation pour garantir que les entrées des joueurs sont correctes.

cppCopy code
// Fonction pour valider les entrées
bool estCoordonneesValides(int ligne, int colonne) {
    return (ligne >= 0 && ligne < 3 && colonne >= 0 && colonne < 3);
}

// Dans la boucle principale
cout << "Entrez la ligne et la colonne (séparées par un espace) : ";
cin >> ligne >> colonne;

// Vérification de la validité de la case
while (!estCoordonneesValides(ligne, colonne) || !estCaseVide(grille, ligne, colonne)) {
    cout << "Coordonnées invalides. Réessayez : ";
    cin >> ligne >> colonne;
}

4. Gestion de Fin de Partie :

Optimisez la gestion de fin de partie en vérifiant si la grille est complètement remplie sans vainqueur.

cppCopy code
// À la fin de la boucle de jeu
if (tour == 8) {
    afficherGrille(grille);
    cout << "Match nul !" << endl;
}

5. Modularité du Code :

Divisez le code en fonctions pour améliorer la modularité et la lisibilité.

cppCopy code
// Fonction pour le tour d'un joueur
void tourDeJoueur(char grille[3][3], Joueur& joueurActuel) {
    // ...
}

// Fonction pour le déroulement complet du jeu
void jouerPartie() {
    // ...
}

// Fonction principale
int main() {
    jouerPartie();
    return 0;
}

Conclusion :

En incorporant ces améliorations, le programme devient plus interactif, offre une expérience utilisateur améliorée, et est plus flexible pour des modifications futures. N'hésitez pas à continuer à personnaliser le code en fonction de vos préférences et à explorer d'autres concepts de programmation C++ pour rendre le jeu encore plus sophistiqué.