Jeu d'échecs en C++

C++ Programmation orientée objet Structures de données Algorithmique Projet scolaire - TPS

Implémentation complète d'un jeu d'échecs en C++ orienté objet, avec gestion des règles avancées, détection d'échec et mat, et interface en ligne de commande.

Code source

Accédez au dépôt GitHub du projet.

Voir sur GitHub

Contexte du projet

Dans le cadre du seconde semestre de ma première année à Télécom Physique Strasbourg, ce projet a consisté à concevoir et implémenter un jeu d'échecs complet en C++ orienté objet. L'objectif pédagogique principal était la maîtrise de la POO : héritage, polymorphisme, surcharge d'opérateurs, gestion dynamique de la mémoire et copie profonde.

Le projet a aboutit à une partie d'échecs jouable en terminal, avec affichage Unicode des pièces et respect de l'intégralité des règles officielles, y compris les cas les plus complexes.

Réalisation technique

Hiérarchie de classes

L'architecture repose sur une classe abstraite Piece dont héritent les six types de pièces :

                // Classe de base abstraite

                class Piece {

                    virtual bool est_mouvement_legal(bool verbeux, const Echiquier& e,

                        const Square& origine, const Square& destination) const = 0;

                    virtual Piece* clone() const = 0;

                };

                // Pièces concrètes : Tour, Cavalier, Fou, Dame, Roi, Pion

Règles avancées implémentées

Roque (petit et grand) : vérification que le roi et la tour n'ont pas bougé, voie libre entre les deux pièces.
Prise en passant : mémorisation de la case traversée lors d'un double pas du pion via un attribut en_passant dans l'échiquier.
Promotion du pion : choix interactif de la pièce de substitution (Dame, Tour, Fou, Cavalier) à l'arrivée en dernière rangée.
Détection d'échec : simulation des mouvements adverses pour détecter si le roi est attaqué.
Échec et mat / Pat : exploration exhaustive de tous les coups légaux pour déterminer si une échappatoire existe.

Simulation par copie profonde

La détection d'échec et mat repose sur la simulation de chaque coup possible. Pour cela, l'échiquier est cloné via un operator= et une méthode clone() sur chaque pièce, garantissant une copie complètement indépendante de l'état de jeu :

                // Pour chaque pièce de la couleur en échec...

                for (auto p : pieces[couleur_en_echec]) {

                    for (int x = 0; x < 8; x++) {

                        for (int y = 0; y < 8; y++) {

                            Echiquier copie = *this; // Copie profonde

                            copie.deplace(false, origine, destination);

                            if (!copie.estEnEchec(...)) return false;

                        }

                    }

                }

Architecture du projet

Piece.hpp / .cpp

Classe abstraite + implémentation des 6 pièces avec leur logique de déplacement

Echiquier.hpp / .cpp

Grille 8×8, gestion des déplacements, captures, roque, promotion, en passant

Jeu.hpp / .cpp

Boucle de jeu, alternance des tours, détection de fin de partie, commandes spéciales

Square.hpp / .cpp

Représentation d'une case (ligne, colonne) avec conversion notation algébrique (ex. e4)

main.cpp

Point d'entrée : initialisation et boucle principale

Makefile

Compilation modulaire, cible de tests et de nettoyage

Résultats & Apprentissages

Types de pièces implémentées

Règles avancées gérées

~1500

Lignes de C++

Classes principales

Ce projet m'a permis de maîtriser concrètement les piliers de la POO en C++ : la conception d'une hiérarchie d'héritage cohérente, le polymorphisme via fonctions virtuelles pures, la surcharge de operator= pour la copie profonde, et la gestion manuelle de la mémoire avec new / delete.

La partie la plus exigeante a été l'implémentation de la détection d'échec et mat : simuler l'intégralité des coups légaux sur une copie de l'échiquier demande une architecture propre et une gestion mémoire irréprochable pour éviter toute fuite ou double libération.

La prise en passant et le roque ont également nécessité de maintenir un état de jeu persistant (drapeaux hasMoved, case en_passant) au-delà du simple état de la grille, ce qui a renforcé la réflexion sur la modélisation des données.

C++ Héritage & Polymorphisme Gestion mémoire Copie profonde Conception orientée objet Algorithmique Débogage Makefile Architecture modulaire