R1.01 – PROG#13 – Exercice 1 : Découverte des tableaux associatifs (map)

Objectif

Contrairement à un vector dont les éléments sont indexés par un entier (0, 1, 2...), un tableau associatif map<Cle, Valeur> (en-tête <map>) permet d’associer une clé unique (par exemple une chaîne de caractères string) à une valeur(par exemple un caractère char représentant une touche ou un symbole). C’est la structure idéale pour stocker des paires clé : valeur issues d’un fichier de configuration YAML.

Dans l’ensemble de ce TP, nous utiliserons l’espace de noms standard (using namespace std;).

Travail à effectuer

Créez un petit programme de test indépendant avant de passer à la refactorisation du jeu.

1. Déclaration, insertion et parcours (afficheMap)

Dans la fonction main() :

  1. Déclarez une variable config de type map<string, char> destinée à stocker les paramètres de configuration du jeu ;
  2. Insérez-y les 4 couples (clé, valeur) suivants (à l’aide de l’opérateur [] ou de .insert(...)) :
    • "toucheHaut" $\rightarrow$ 'z'
    • "toucheBas" $\rightarrow$ 's'
    • "toucheGauche" $\rightarrow$ 'a'
    • "toucheDroite" $\rightarrow$ 'e'
  3. Écrivez la fonction afficheMap de signature :
void afficheMap (const map<string, char> & maMap);

Cette fonction parcourt maMap pour afficher chaque couple sous la forme cle : valeur (vous pouvez utiliser une boucle par plage for (const pair<const string, char> & paire : maMap) en accédant à paire.first et paire.second, ou un itérateur map<string, char>::const_iterator). Appelez afficheMap(config) dans le main(). Dans quel ordre les clés s’affichent-elles ? Pourquoi ?

2. Insertion sécurisée et généricité (insertIfNotExists et afficheMap)

  1. Écrivez la fonction insertIfNotExists de signature :
void insertIfNotExists (map<string, char> & maMap,
                        const string & cle,
                        char valeur);

Cette fonction ne doit insérer le couple (cle, valeur) dans maMap que si la clé n’existe pas déjà (utilisez maMap.find(cle) == maMap.end()).

  1. Rendez ensuite générique votre fonction d’affichage afficheMap en modifiant sa signature comme suit :
template <typename T, typename U>
void afficheMap (const map<T, U> & maMap);
  1. Testez vos deux fonctions dans le main() en tentant d’ajouter "toucheHaut" avec 'w' (qui doit être ignoré car la clé existe déjà), puis "symboleJoueur" avec 'X' (qui doit être ajouté), et affichez le résultat avec afficheMap.

3. Application : lire un fichier config.yaml dans une map<string, char>

Créez un fichier config.yaml contenant :

toucheHaut: z
toucheBas: s
toucheGauche: a
toucheDroite: e
symboleJoueur: X
symboleDrapeau: O

Écrivez une fonction chargerConfigYAML de signature :

map<string, char> chargerConfigYAML (const string & nomFichier,
                                     const map<string, char> & configDefaut);
  • Si le fichier nomFichier n’existe pas (échec d’ouverture du flux ifstream), la fonction doit immédiatement retourner configDefaut (passée en paramètre, comme la map définie à la question 1).
  • Sinon, elle lit le fichier ligne par ligne (getline), découpe chaque ligne autour du caractère ':' (find et substr, en récupérant le caractère non-espace associé) et stocke chaque paire dans la map retournée (vous pouvez partir d’une copie de configDefaut afin que toute clé absente du fichier conserve sa valeur par défaut).
  • Testez votre fonction dans le main() avec le fichier config.yaml, puis avec un nom de fichier inexistant ("inexistant.yaml"), et affichez les résultats avec afficheMap.

R1.01 – PROG#13 – Exercice 2 : Découpage modulaire et compilation stricte

Objectif

Dans un projet logiciel professionnel (et dans le cadre de la SAÉ 1.01), tout le code ne doit jamais résider dans un unique fichier main.cpp. L’objectif de cet exercice est de segmenter votre projet du TP 10 sous Qt Creator (QMake) tout en garantissant une compilation sans aucun avertissement (warning).

Travail à effectuer

1. Configuration stricte du compilateur

  1. Ouvrez votre projet du TP 10 dans Qt Creator (ou créez un nouveau projet Application console C++ avec qmake en y copiant votre code fonctionnel du TP 10).
  2. Ouvrez le fichier de projet .pro et ajoutez la ligne suivante afin d’activer les vérifications strictes du compilateur C++ :
QMAKE_CXXFLAGS += -Wall -Wextra -pedantic
  1. Compilez votre projet (Ctrl + B) et corrigez tous les warnings éventuels (variables non utilisées, comparaisons entre int et unsigned / size_t, ordre d’initialisation, etc.).

2. Segmentation en fichiers d’en-tête (.h) et sources (.cpp)

Découpez votre code existant en créant les fichiers suivants dans votre projet Qt Creator (Clic droit sur le projet -> Ajouter nouveau -> C++ -> Fichier d’en-tête C++ / Fichier source C++) :

Fichier(s) Contenu à déplacer / créer
constantes.h Toutes les constantes du programme : codes couleurs VT100 (KReset, KRouge, KVert, KBleu, KMagenta…), symboles de la grille (kSymboleJoueur1, kSymboleArrivee, kMur, kEmpty…), touches par défaut (kToucheHautDefaut, kToucheBasDefaut, kToucheGaucheDefaut, kToucheDroiteDefaut), ainsi que la map<string, char> constante kConfigDefaut associant les touches et symboles par défaut. Aucun caractère ou nombre « magique » ne doit subsister dans les .cpp.
type.h Les définitions de types et structures de données (ligne, matrice2D, position).
affichage.h / affichage.cpp Les fonctions liées au terminal VT100 et au rendu (clearScreen, couleur, showmatrice2D).
jeu.h / jeu.cpp Les règles et mécaniques du jeu (initmat, moveToken, getch).
labyrinthe.h / labyrinthe.cpp La fonction de génération aléatoire de labyrinthe fournie au TP 10 (genererLabyrinthe, estValide).
main.cpp Uniquement la fonction ppal() (ou le menu de lancement) et main().

Dans constantes.h, déclarez notamment la configuration par défaut sous la forme :

const map<string, char> kConfigDefaut = {
    {"toucheHaut",     kToucheHautDefaut},
    {"toucheBas",      kToucheBasDefaut},
    {"toucheGauche",   kToucheGaucheDefaut},
    {"toucheDroite",   kToucheDroiteDefaut},
    {"symboleJoueur",  kSymboleJoueur1},
    {"symboleDrapeau", kSymboleArrivee}
};

Points de vigilance obligatoires

  • Protection contre les inclusions multiples : Chaque fichier .h doit impérativement être encadré par des directives de préprocesseur :
#ifndef CONSTANTES_H
#define CONSTANTES_H

// Vos déclarations et constantes ici

#endif // CONSTANTES_H
  • Vérifiez que le projet compile sans aucun warning et que le jeu fonctionne exactement comme à la fin du TP 10.

R1.01 – PROG#13 – Exercice 3 : Centralisation des paramètres de jeu

Objectif

Pour éviter de multiplier les paramètres passés à vos fonctions (moveToken, showmatrice2D, etc.) et permettre au joueur de personnaliser ses touches ou ses symboles depuis le fichier config.yaml vu à l’exercice 1, nous allons regrouper la configuration du jeu dans une struct.

Travail à effectuer

  1. Dans type.h, définissez la structure parametres contenant les champs suivants (initialisés avec les valeurs par défaut définies dans constantes.h) :
struct parametres {
    char toucheHaut   = kToucheHautDefaut;   // ex: 'z'
    char toucheBas    = kToucheBasDefaut;    // ex: 's'
    char toucheGauche = kToucheGaucheDefaut; // ex: 'a'
    char toucheDroite = kToucheDroiteDefaut; // ex: 'e'

    char symboleJoueur  = kSymboleJoueur1;
    char symboleDrapeau = kSymboleArrivee;
    char symboleMur     = kMur;
    char symboleVide    = kEmpty;

    unsigned couleurJoueur  = KRouge;
    unsigned couleurDrapeau = KBleu;
    unsigned couleurMur     = KMagenta;
};
  1. Dans jeu.h et jeu.cpp, ajoutez une fonction permettant d’initialiser ces paramètres en appelant chargerConfigYAML(nomFichierConfig, kConfigDefaut) de l’exercice 1 (ainsi, si config.yaml est absent, le jeu démarre sans erreur avec kConfigDefaut) :
void initParams (parametres & params, const string & nomFichierConfig);
  1. Modifiez les signatures et les corps de showmatrice2D et moveToken pour qu’elles reçoivent const parametres & params et utilisent les champs de cette structure plutôt que des constantes figées.
    • Rappel : Vérifiez que moveToken gère toujours les minuscules et les majuscules (à l’aide de tolower de <cctype> par exemple) et n’incrémente nbCoup que si le déplacement est valide.

R1.01 – PROG#13 – Exercice 4 : Chargement d’un niveau depuis un fichier YAML (initJeuFichier)

R1.01 – PROG#13 – Exercice 4 : Chargement d'un niveau depuis un fichier YAML (initJeuFichier)

Objectif

La SAÉ 1.01 impose de pouvoir charger des niveaux prédéfinis stockés dans des fichiers au format YAML (.yaml ou .yml). Vous allez implémenter la fonction de chargement et de validation dans le module labyrinthe.

Travail à effectuer

1. Format du fichier de niveau

Créez un fichier nommé niveau1.yaml dans le répertoire d’exécution (ou un sous-dossier niveaux/ accessible par chemin relatif) avec le contenu exact suivant :

nbLignes: 7
nbColonnes: 11
joueur:
  ordonnee: 1
  abscisse: 1
drapeau:
  ordonnee: 5
  abscisse: 9
grille:
  ###########
  #   #     #
  # # # ### #
  # #     # #
  # ##### # #
  #       # #
  ###########

(Notez que les lignes de la grille sous grille: sont indentées par 2 espaces en YAML).

2. Signature et spécifications de la fonction

Dans labyrinthe.h et labyrinthe.cpp, déclarez et implémentez la fonction suivante :

bool initJeuFichier (const string & nomFichier,
                     matrice2D & mat,
                     position & posJoueur,
                     position & posDrapeau,
                     const parametres & params);

La fonction renvoie true si le fichier a été lu et validé avec succès, et false en cas d’erreur (fichier introuvable, format incorrect, dimensions incohérentes, joueur ou drapeau hors limites ou sur un mur).

3. Étapes d’implémentation conseillées

  1. Ouverture du flux : Ouvrez le fichier en lecture avec ifstream ifs(nomFichier);. Si !ifs.is_open(), affichez un message d’erreur explicite et retournez false.
  2. Extraction des métadonnées (nbLignes, nbColonnes, joueur, drapeau) :
    • Lisez le fichier ligne par ligne avec getline(ifs, ligneCourante).
    • Utilisez ligneCourante.find(':') et ligneCourante.substr(...) pour extraire la valeur entière après le caractère : (convertie avec stoi).
    • Astuce : Prenez garde à distinguer ordonnee: et abscisse: pour joueur puis pour drapeau (qui apparaissent dans cet ordre dans le fichier).
  3. Lecture du bloc grille: :
    • Une fois la ligne grille: rencontrée, lisez les nbLignes lignes suivantes.
    • Pour chaque ligne lue, retirez les 2 premiers caractères d’indentation (ligneCourante.substr(2)), puis vérifiez que sa longueur correspond bien à nbColonnes.
    • Remplacez les caractères '#' et ' ' lus par params.symboleMur et params.symboleVide dans mat.
  4. Placement et vérification de cohérence :
    • Vérifiez que posJoueur et posDrapeau sont bien à l’intérieur des bornes de mat (ordonnee < nbLignes et abscisse < nbColonnes) et que les cases correspondantes ne contiennent pas un mur (params.symboleMur).
    • Placez params.symboleJoueur et params.symboleDrapeau dans mat aux coordonnées lues.
  5. Test dans main.cpp :
    • Proposez à l’utilisateur au lancement de choisir entre 1. Labyrinthe aléatoire et 2. Charger un niveau YAML (en saisissant le nom du fichier).
    • Testez également votre fonction avec un fichier inexistant et avec un fichier volontairement corrompu (mauvais nombre de colonnes, joueur sur un mur) pour vérifier la robustesse de votre code.

R1.01 – PROG#13 – Exercice 5 : Persistance des meilleurs scores en YAML (Top 10)

Objectif

Afin de conserver les meilleures performances des joueurs entre deux lancements du jeu, vous allez créer le module scores.h / scores.cpp chargé de lire, mettre à jour, trier et sauvegarder un classement Top 10 au format YAML.

Travail à effectuer

1. Structure de données et format du fichier scores.yaml

Dans type.h, ajoutez la structure représentant une entrée du classement :

struct score {
    string pseudo;
    unsigned nbCoups;
    string niveau; // ex: "niveau1.yaml" ou "Aleatoire 11x11"
};

Le fichier scores.yaml aura la structure YAML suivante (liste d’objets) :

scores:
  - pseudo: Alice
    nbCoups: 18
    niveau: niveau1.yaml
  - pseudo: Bob
    nbCoups: 24
    niveau: niveau1.yaml

2. Fonctions à implémenter dans scores.h / scores.cpp

Implémentez les quatre fonctions suivantes :

  1. Chargement des scores :
vector<score> chargerScores (const string & nomFichier);

Lit le fichier scores.yaml s’il existe et retourne le vecteur des scores enregistrés (si le fichier n’existe pas encore, retourne simplement un vecteur vide sans générer d’erreur).

  1. Ajout et tri du Top 10 :
void ajouterScore (vector<score> & listeScores, const score & nouveauScore);
  • Insère nouveauScore dans listeScores.
  • Trie listeScores par ordre croissant de nbCoups (le plus petit nombre de coups est en première position — vous pouvez réutiliser votre tri par sélection/échange du TP 9 ou sort).
  • Si la taille de listeScores dépasse 10, supprime les éléments excédentaires (listeScores.resize(10);).
  1. Sauvegarde dans le fichier YAML :
bool sauvegarderScores (const string & nomFichier, const vector<score> & listeScores);

Écrit l’intégralité de listeScores dans nomFichier (ofstream) en respectant strictement l’indentation YAML présentée ci-dessus.

  1. Affichage du classement (dans affichage.h / affichage.cpp) :
void afficherTop10 (const vector<score> & listeScores);

Affiche proprement le tableau des meilleurs scores dans le terminal avec mise en couleur VT100 (par exemple en jaune/or pour le 1er).

3. Intégration dans la boucle de jeu

À la fin d’une partie victorieuse dans ppal() :

  1. Demandez le pseudo du joueur (sans espace) ;
  2. Chargez les scores existants depuis scores.yaml, ajoutez le nouveau score, puis sauvegardez le Top 10 mis à jour ;
  3. Affichez le classement actualisé avant de revenir au menu principal.

2026- 2027 – SAE 1.01

SAÉ 1.01 – Implémentation d’un besoin client : Capture The Flag

1. Contexte et objectifs (Programme National B.U.T. Informatique)

Dans le cadre de la Compétence 1 (Réaliser un développement d’application) du Programme National du B.U.T. Informatique, cette Situation d’Apprentissage et d’Évaluation (SAÉ 1.01) répond à la problématique professionnelle suivante : créer tout ou partie d’une application simple à partir d’un besoin client.
Dans la continuité du TP 10 (R1.01 – Prog#10), vous allez développer en équipe de 3 étudiants une version complète, modulaire et évolutive du jeu en mode console (terminal GNU/Linux avec émulation VT100) Capture The Flag.
Ce projet mobilise directement les quatre Apprentissages Critiques du niveau 1 :
  • AC11.01 – Implémenter des conceptions simples : traduire les règles du jeu et le cahier des charges en algorithmes et fonctions C++ claires.

  • AC11.02 – Élaborer des conceptions simples : découper l’application en modules cohérents (.h / .cpp) et concevoir des structures de données adaptées (type.h).

  • AC11.03 – Faire des essais et évaluer leurs résultats en regard des spécifications : tester systématiquement les cas limites (débordements de grille, fichiers mal formés, collisions) pour garantir un programme sans bug.

  • AC11.04 – Développer des interfaces utilisateurs : concevoir une interface console ergonomique,lisible et réactive (couleurs VT100, menus, affichage des règles et du classement).

2. Architecture et segmentation obligatoire du code

Tout le code ne doit plus résider dans un unique fichier main.cpp. Vous devez impérativement découper votre projet Qt Creator (build system QMake) en respectant la segmentation suivante :
Fichier(s) Rôle et contenu attendu
type.h
Définition des structures de données et alias de types utilisés dans tout le projet (ligne, matrice2D, position, ainsi que les structures dédiées aux entités, aux nœuds de recherche de chemin ou aux scores).
constantes.h
Centralisation de toutes les constantes du programme : codes couleurs VT100 (KReset, KRouge, KMagenta…), symboles de la grille (kSymboleJoueur1, kSymboleArrivee, kMur, kVide…) et chaînes de touches autorisées (kSaisieAutorisee). Aucun « nombre magique » ou caractère en dur ne doit apparaître dans le code.
labyrinthe.h / labyrinthe.cpp
Gestion de la génération procédurale de la grille (genererLabyrinthe, estValide) ainsi que le chargement de niveaux prédéfinis depuis un fichier au format YAML (initJeuFichier).
affichage.h / affichage.cpp(recommandé)
Fonctions liées au rendu en mode console VT100 (clearScreen, couleur, showmatrice2D, affichage des règles, du HUD et du Top 10).
jeu.h / jeu.cpp(recommandé)
Logique métier et règles du jeu (initMat, moveToken, gestion des interactions, conditions de victoire/défaite).
chemin.h / chemin.cpp(selon options) Implémentation des algorithmes de déplacement et de recherche de plus court chemin (ex. A*) pour les gardes du labyrinthe.
scores.h / scores.cpp(selon options) Gestion de la persistance des scores au format YAML (lecture, tri et écriture du classement Top 10 dans un fichier).
main.cpp
Point d’entrée minimaliste du programme (main et boucle principale ppal ou appel au menu principal).
Règle de compilation : Tous les fichiers d’en-tête (.h) doivent être protégés contre les inclusions multiples à l’aide de directives #ifndef / #define / #endif. Votre projet doit compiler sans aucun warning avec les options -Wall -Wextra -pedantic.

3. Fonctionnalités attendues

Niveau 1 : Socle technique (Base minimale exigée)

Votre programme doit intégrer et finaliser l’ensemble des mécaniques vues lors du TP 10 :
  • Deux modes d’initialisation de carte :

    1. Génération aléatoire : Création d’un labyrinthe parfait de dimensions paramétrables (avec ajustement automatique aux dimensions impaires minimales $5 \times 5$ pour garantir un cadre régulier).

    2. Chargement depuis un fichier au format YAML (initJeuFichier) : Lecture d’un fichier de niveau (.yamlou .yml) structuré de la manière suivante :

      YAML

      nbLignes: 7
      nbColonnes: 11
      joueur:
        ordonnee: 1
        abscisse: 1
      drapeau:
        ordonnee: 5
        abscisse: 9
      grille: |
        ###########
        #   #     #
        # # # ### #
        # #     # #
        # ##### # #
        #       # #
        ###########
      
  • Affichage ergonomique (showmatrice2D) : Encadrement propre de la grille (y compris sur des grilles rectangulaires) et coloration distincte des éléments dans la console (joueur, drapeau, murs, bonus, ennemis).

  • Déplacement fluide et sécurisé (moveToken & getch) :

    • Lecture clavier instantanée sans validation par la touche Entrée (termios.h).

    • Gestion des touches minuscules et majuscules (a, z, e, s).

    • Sécurité stricte des bornes : Empêcher toute sortie de tableau (notamment lorsque le joueur est placé sur le bord supérieur à l’entrée 'E' en (0, 1) et appuie sur 'z') ainsi que le franchissement des murs ('#').

    • Comptage des coups : Par défaut, un déplacement invalide (touche non reconnue, mur ou bord de grille) ne doit pas incrémenter le compteur de déplacements (nbCoup), sauf si vous décidez d’instaurer une règle de pénalité (par exemple : foncer dans un mur ajoute $+1$ coup de pénalité),ce qui constitue une variante tout à fait envisageable à condition qu’elle soit clairement expliquée dans les règles du jeu.

Niveau 2 : Évolutions et fonctionnalités avancées

À partir de ce socle fonctionnel, vous devez enrichir l’expérience de jeu en implémentant au moins 3 fonctionnalités majeures parmi les pistes suivantes (ou toute proposition validée par votre enseignant) :
  1. Mode 2 Joueurs (Affrontement ou Coopération) :

    • Ajout d’un second joueur (kSymboleJoueur2, utilisant un second jeu de touches alphabétiques tel que i, j, k, l ou o, k, l, m — évitez les flèches directionnelles, dont les séquences de touches diffèrent selon la configuration des claviers et des terminaux) dans la même arène.

    • Variante Course : Le premier qui atteint le drapeau remporte la manche.

    • Variante Capture & Retour : Chaque joueur doit récupérer le drapeau adverse et le ramener à sa propre base de départ.

  2. Ennemis mobiles / Gardes du labyrinthe (à la manière de Pac-Man) :

    • Ajout d’entités autonomes ('M') occupant les couloirs du labyrinthe, inspirées des fantômes du jeu d’arcade Pac-Man.

    • Le comportement de ces gardes est libre et peut être gradué : ils peuvent rester statiques(sentinelles bloquant un passage), effectuer des mouvements simples ou « idiots » (comme un aller-retour gauche/droite ou haut/bas, ou des déplacements aléatoires), ou bien traquer activement le joueur.

    • Exemple avancé : Pour calculer le plus court chemin permettant aux gardes de poursuivre le joueur à travers le labyrinthe, vous pouvez implémenter l’algorithme A* (en utilisant par exemple la distance de Manhattan comme heuristique sur votre grille 2D). Vous pouvez vous appuyer sur la documentation et le pseudo-code détaillés sur la page Wikipédia de l’Algorithme A*.

    • Le contact avec un garde fait perdre une vie ou réinitialise la position du joueur.

  3. Système d’objets, pièges et brouillard de guerre :

    • Brouillard de guerre (Fog of War) : Le joueur ne voit les cases du labyrinthe que dans un rayon de $N$ cases autour de sa position.

    • Objets interactifs : Clés ('K') ouvrant des portes verrouillées ('D'), téléporteurs ('T'), ou bonus réduisant le compteur de pas.

  4. Campagne multi-niveaux, sauvegarde des scores et affichage du Top 10 :

    • Enchaînement automatique de plusieurs fichiers de niveaux au format YAML (niveau1.yaml,niveau2.yaml, etc.) avec difficulté croissante.

    • Sauvegarde persistante des scores (pseudo du joueur et nombre total de coups) dans un fichier externe au format YAML (scores.yaml), accompagnée d’un affichage trié du Top 10 des meilleurs scores (du plus petit nombre de coups au plus grand) consultable depuis le menu principal et à la fin d’une partie.

  5. Menu principal interactif :

    • Sélection du mode de jeu (Labyrinthe aléatoire / Chargement de fichier / Campagne), choix de la taille de la grille, consultation du Top 10, affichage des règles (lues depuis votre fichier texte) et écran de fin de partie détaillé.

4. Documentation technique du code (Doxygen)

L’ensemble de vos fichiers d’en-tête (.h) et de vos structures de données doit être commenté selon la syntaxe standard Doxygen (/** ... */ ou ///, balises @brief, @param, @return — voir la documentation officielle des blocs de commentaires).
Vous devez générer la documentation de votre projet à l’aide de doxygen et/ou de doxywizard (disponibles sur le site officiel de Doxygen) en veillant impérativement aux contraintes suivantes :
  1. Inclure les graphes des fonctions appelées (CALL_GRAPH = YES) et des fonctions appelantes (CALLER_GRAPH = YES).

  2. Fixer la profondeur maximale de ces graphes à 4 (MAX_DOT_GRAPH_DEPTH = 4).

5. Modalités de rendu et soutenance

  • Date limite de dépôt : Avant le vendredi 18 décembre à 20h00 sur la plateforme Ametice.

  • Soutenance : Prévoir une présentation orale d’environ 10 minutes lors de la semaine du 4 janvier.

  • Nomenclature obligatoire de l’archive :TD_AA_E_BB_YYYY_ZZZ_BBBB.zip

    • AA : votre groupe de TD ;

    • BB : votre numéro d’équipe ;

    • YYYY, ZZZ, BBBB : les noms des 3 étudiants de votre équipe, triés par ordre alphabétique.

Contenu de l’archive .zip

Votre archive (au format .zip strictement, et ne contenant aucun binaire / exécutable ni fichier .o) devra contenir :
  1. Un rapport au format PDF expliquant ce que vous avez fait (architecture logicielle, choix des structures de données, algorithmes implémentés, répartition du travail).

  2. Un répertoire contenant la documentation Doxygen que vous avez générée (avec le Doxyfile et les graphes des fonctions appelées/appelantes de profondeur 4).

  3. Un fichier texte expliquant comment on joue à votre jeu et les règles du jeu.

    Astuce : Vous pouvez lire ce fichier et le faire afficher directement dans votre programme (via le menu principal par exemple). En revanche, faites bien attention à son chemin / son emplacement relatif lors de l’exécution !

  4. Un dossier contenant votre projet Qt Creator (build system QMake, fichiers .pro, .h, .cpp et fichiers de niveaux .yaml).

6. Barème et pénalités

Barème de notation (sur 20 points)

  • Code source et fonctionnalités : 12 pts

  • Présentation orale : 3 pts

  • Rapport PDF : 2 pts

  • Documentation Doxygen : 2 pts

  • Auto-évaluation d’équipe : 1 pt à vous répartir entre vous selon le principe suivant :

    • Chaque étudiant de chaque groupe de projet dispose de 1 point qu’il peut répartir comme il le souhaite entre les membres de son équipe.

    • En conséquence, pour une équipe de 3 étudiants, vous disposez de 3 points à vous répartir.

Pénalités appliquées

  • Qualité rédactionnelle (Rapport & Slides) : Si plus de 2 fautes d’orthographe par page ou par slide $\Rightarrow$ -1 pt.

  • Bugs à l’exécution :

    • 1er bug découvert $\Rightarrow$ -3 pts ;

    • 2e bug découvert $\Rightarrow$ -2 pts ;

    • 3e bug découvert $\Rightarrow$ -1 pt ;

    • On s’arrêtera là : si vous avez au moins 3 bugs, cela vous donne un malus maximal de -6 pts.

  • Triche et intégration de code tiers (développeur externe, LLM / IA générative, etc.) :

    • Copie sur un autre groupe $\Rightarrow$ 0/20 + conseil de discipline.

    • Intégration de code provenant d’un tiers (externe ou LLM) sans le sourcer $\Rightarrow$ traité comme une copie (0/20 + conseil de discipline).

    • Intégration de code provenant d’un tiers en le sourçant explicitement :

      • Note / 2 sur la partie concernée si vous êtes capables d’expliquer parfaitement le code lors de la soutenance ;

      • Note = 0 (assimilé à de la copie) dans le cas contraire.

R1.01 – PROG#10 – EXERCICE 2 – Capture The Flag : Déplacement sur une grille vide

Objectif

L’objectif de cet exercice est de manipuler une grille (matrice 2D de caractères) afin d’y placer un joueur (X) et un drapeau (O), puis de permettre au joueur de se déplacer jusqu’à atteindre l’arrivée[cite: 1].

Structures de données et constantes

Pour représenter la grille et les positions, nous utiliserons les types et constantes suivants[cite: 1] :

typedef vector <char> ligne; // un type représentant une ligne de la grille
typedef vector <ligne> matrice2D; // un type représentant la grille
struct position {
    unsigned abscisse;
    unsigned ordonnee;
}; // un type représentant une coordonnée dans la grille

const char kSymboleJoueur1 = 'X';
const char kSymboleArrivee = 'O';
const char kEmpty          = ' ';

Travail à effectuer

1. Initialisation de la grille (initmat)

Testez la fonction initmat fournie dans le squelette de code[cite: 1] :

void initmat (matrice2D & mat, unsigned nbligne, unsigned nbColumn,
              position & positionJoueur, position & posDrapeau)
  • Le joueur (X) doit être placé en haut à droite de la grille et le drapeau (O) en bas à gauche[cite: 1].
  • Testez cette fonction avec une grille rectangulaire (par exemple 6 lignes et 12 colonnes). Que constatez-vous ? Corrigez l’initialisation des coordonnées du joueur et du drapeau pour qu’elle fonctionne quelle que soit la taille de la grille[cite: 1].

2. Affichage de la grille (showmatrice2D)

Analysez et appelez la fonction showmatrice2D[cite: 1] :

void showmatrice2D (const matrice2D & mat)
  • Cette fonction encadre la grille avec des - et des |, et affiche le joueur en rouge (KRouge) et le drapeau en bleu (KBleu)[cite: 1].
  • Observez le rendu sur une grille rectangulaire : les bordures horizontales ont-elles la bonne longueur ? Corrigez le bug[cite: 1].

3. Déplacement du joueur (moveToken)

Examinez la fonction moveToken[cite: 1] :

void moveToken (matrice2D & mat, char deplacement, position & pos, ushort & nbCoup)

Les touches autorisées sont 'a' (gauche), 'z' (haut), 'e' (droite) et 's' (bas)[cite: 1].

  • Que se passe-t-il si le joueur tente de sortir des limites de la grille (par exemple aller à droite alors qu’il est déjà sur la dernière colonne, ou monter depuis la ligne 0) ? Corrigez la fonction pour empêcher toute sortie de grille[cite: 1].
  • Vérifiez également la gestion des majuscules et le comptage du nombre de coups (nbCoup)[cite: 1].

4. Boucle principale (ppal)

Assemblez le tout dans la fonction ppal : tant que le joueur n’a pas atteint la position du drapeau, on affiche la grille, on lit la saisie clavier avec cin.get(), on déplace le joueur et on efface l’écran (clearScreen())[cite: 1]. À la fin de la partie, affichez le nombre de déplacements effectués[cite: 1].

Astuce : attention au caractère retour chariot '\n' laissé dans le flux d’entrée par cin.get() lors de la validation avec la touche Entrée.

R1.01 – PROG#10 – EXERCICE 3 – Capture The Flag : Ajout des murs du labyrinthe

Objectif

Nous allons maintenant transformer cette grille vide en un véritable labyrinthe en y ajoutant des murs infranchissables représentés par le caractère '#' :

const char kMur = '#';

Travail à effectuer

1. Génération du labyrinthe

Remplacez l’appel à initmat en vous inspirant de la fonction de génération de labyrinthe fournie (qui initialise la matrice avec des espaces, des murs '#', ainsi que les positions de départ et d’arrivée).

2. Affichage des murs (showmatrice2D)

Modifiez la fonction showmatrice2D afin que les murs (kMur) soient affichés en magenta (KMagenta).

3. Gestion des collisions (moveToken)

Modifiez la fonction moveToken pour empêcher le joueur de traverser les murs :

  • Si la case de destination contient un mur (kMur), le joueur reste à sa position initiale (et le coup n’est pas comptabilisé)[cite: 1].
  • Sinon, le déplacement s’effectue normalement.

R1.01 – PROG#10 – EXERCICE 4 – Capture The Flag : Déplacement fluide sans validation

Objectif

Jusqu’à présent, l’utilisation de cin.get() obligeait le joueur à appuyer sur la touche Entrée après chaque direction. Pour rendre le jeu plus dynamique, nous allons lire les touches clavier instantanément, sans avoir à valider par Entrée et sans afficher la touche tapée dans le terminal[cite: 1].

Fonction fournie

Ajoutez les en-têtes <termios.h> et <unistd.h> ainsi que la fonction getch() suivante à votre programme (source) :

#include <termios.h>
#include <unistd.h>

// Fonction POSIX pour lire un caractère sans Entrée et sans l'afficher
char getch() {
    char buf = 0;
    struct termios old_tio, new_tio;

    tcgetattr(STDIN_FILENO, &old_tio); // Sauvegarde des paramètres actuels
    new_tio = old_tio;
    new_tio.c_lflag &= ~(ICANON | ECHO); // Désactivation du mode canonique et de l'écho
    tcsetattr(STDIN_FILENO, TCSANOW, &new_tio); // Application des nouveaux paramètres

    read(STDIN_FILENO, &buf, 1); // Lecture d'un seul caractère

    tcsetattr(STDIN_FILENO, TCSANOW, &old_tio); // Restauration des paramètres initiaux
    return buf;
}

Travail à effectuer

  1. Remplacez la lecture clavier dans la fonction ppal() par un appel à getch().
  2. Testez le jeu : les déplacements doivent désormais s’effectuer en temps réel à la moindre pression sur a, z, e ou s.