École de technologie supérieure Génie de la production automatisée
GPA665
Structures de données et algorithmes
Laboratoire 1
Jeu Démineur
Responsable du cours : Mohamed Cheriet, ing., Ph. D.
Rédaction du laboratoire : Jean-Christophe Demers Révision et barème de correction : Yan Levasseur & Mathieu Binette Temps alloué pour ce laboratoire : 4 périodes de laboratoire
Résumé
Le développement de jeux informatisés requiert souvent une conception robuste doublée de la mise sur pied de structures de données adaptées, qui permettent d’atteindre la rapidité voulue tout en offrant quantité d’options. Ce laboratoire consiste en la création du fameux jeu Démineur (populaire sous Windows et autres systèmes).
La conception et l’implémentation du programme de Démineur demandent l’utilisation de plusieurs concepts reliés au cours de Structure de données et algorithmes. Parmi ceux-ci on note la gestion dynamique de la mémoire avec tableau dynamique en 2D, l’utilisation de fonction avec passage de paramètres par valeur et par référence et finalement l’utilisation d’une fonction récursive
Il vous est aussi demandé de développer le jeu avec une attention particulière sur la méthode de programmation, qui devra être rigoureuse et tenir compte des concepts fondamentaux de qualité des logiciels.
Le jeu démineur
L’objectif du jeu
Le jeu démineur est un jeu de chance et d’analyse logique qui consiste à localiser toutes les mines présentes sur la grille de jeu sans en mettre aucune à nu.
À titre de référence, ce jeu vient avec le système d’exploitation Windows (dépendamment des options d’installation).
La grille de jeu et comment jouer
Le jeu est constitué d’une grille rectangulaire ou carrée où sont cachées les mines. Au fur et à mesure que le jeu avance, certaines cases de la grille sont explorées et des informations apparaissent. Si le joueur explore une case contenant une mine, le jeu se termine. Si le joueur explore une case adjacente à une mine, on voit apparaître un chiffre indiquant le nombre de mines adjacentes à la case. Dans les autres cas, on voit apparaître la surface contiguë qui est libre de mine.
De plus, pour aider le joueur à mémoriser les endroits qu’il croit minés, il peut les identifier comme des cases minées.
Pour gagner
Pour gagner la partie, le joueur doit identifier toutes les cases qui ne sont pas minées.
Le travail à faire
Pour ce laboratoire, vous devez concevoir et programmer le jeu démineur. Le but du laboratoire étant de se familiariser avec certaines structures de données et leurs algorithmes, la programmation se fera en mode console (mode texte) au lieu d’être en mode graphique.
Vous aurez à gérer l’affichage des différents états du jeu lors de l’avancement de la partie ainsi que les commandes du joueur.
Sur le site web du cours se trouve un exemple de ce que vous devez réaliser.
Contraintes d’implantation
1. Plateforme de développement : Vous devez utiliser le logiciel Visual C++ pour réaliser votre programme. Il est fortement suggéré de réaliser la programmation en mode console (mode texte). Par contre, il est possible de programmer en C++
sous Windows pour ceux qui connaissent déjà ce langage.
2. Démarrage du jeu : Lorsque votre programme est lancé, ce dernier doit demander au joueur quel est le niveau de difficulté désiré ou s’il désire quitter.
Ensuite, dans le cas où le joueur désire jouer, le programme demande la taille de la grille de jeu que le joueur désire. La taille de la grille doit être de 10 cases au moins en X et en Y, 75 cases au plus en X et 18 cases au plus en Y. Ensuite, le programme doit positionner aléatoirement les mines sur la grille de jeu. Il existe 5 niveaux de difficultés correspondant au nombre de mines sur le terrain. Ce nombre est défini en pourcentage par rapport à la surface de la grille de jeu :
Niveau Difficulté Pourcentage du nombre de mine
1
Très facile 5 %2
Facile 10 %3
Moye 15 %4
Difficile 20 %5
Très difficile 25 %3. Affichage de la grille de jeu : Votre programme doit afficher l’état courant de la partie ainsi que plusieurs autres informations. Les deux premières lignes sont réservées pour afficher verticalement les nombres identifiant les différentes colonnes (de 01 à m où m varie de 10 à 78). Chacune de ces deux lignes doit débuter par deux espaces. La troisième ligne est réservée pour la partie supérieure du cadre qui identifie la position de la grille de jeu. Les n lignes suivantes sont réservés pour afficher la grille de jeu. Chacune de ces lignes doit débuter par une lettre de référence qui identifie la ligne (de A à n où n varie de K pour n = 10 à R pour n = 18). Suit le caractère de contour de la zone graphique et m éléments de la grille de jeu. Finalement on retrouve le caractère du contour de la grille de jeu. La ligne suivante affiche la partie inférieure du cadre qui identifie la grille de jeu. La ligne suivante doit afficher le nombre de mines identifiées sur le nombre total de mines. Sur la même ligne, on peut afficher facultativement quelques rappels sur les commandes permises. Ensuite, sur la dernière ligne restante au bas de l’écran, votre programme doit afficher un message qui doit inviter le joueur à saisir sa commande. Voici un exemple :
À titre de référence, voici les caractères Ascii utilisés pour les différentes parties de l’affichage dans l’exemple précédent.
Description Code Ascii Exemple
Coin supérieur gauche du tableau 201 ╔
Coin supérieur droit du tableau 187 ╗
Coin inférieur gauche du tableau 200 ╚
Coin inférieur droit du tableau 188 ╝
Bande horizontale du tableau 205 ═
Bande verticale du tableau 186 ║
Zone ombragée 177 ▒
Mine identifiée 77 M
Mine explosée 42 *
4. Les commandes permises : Il y a seulement 3 commandes permises et seulement l’appui sur une touche doit permettre son activation. Voici un tableau récapitulatif de ces commandes :
Commande Touche
d’activation Description Quitter Q ou q
Quitte la partie et retourne au menu principal. Le programme doit demander confirmation au joueur avant de quitter.
Explorer une case E ou e
Explore une case de la grille de jeu. Le programme doit demander les
coordonnées au joueur.
Définir une case en
tant que Mine M ou m
Définit une case de la grille de jeu comme étant une case ayant une mine. Le
programme doit demander les coordonnées au joueur.
5. Structure de données : Vous devez implanter une structure de données qui vous est imposée. Puisque l’usager décide de la taille de la grille de jeu, vous devez allouer en mémoire un tableau 2D de la même taille que la grille de jeu. Cette allocation dynamique permet une meilleure gestion des ressources. N’oubliez pas que le tableau doit être réalloué à chaque nouvelle partie.
Rappel sur les tableaux 2D : On sait que les tableaux sont étroitement liés aux pointeurs.
En fait, la variable associée à un tableau est un pointeur du type correspondant au tableau qui « pointe » directement sur le premier espace mémoire contigu alloué pour les données du tableau. Dans le cas d’un tableau 2D dont l’allocation est dynamique, il faut comprendre que chaque ligne (ou colonne dépendant du point de vue) est allouée indépendamment des autres. Ainsi, on doit allouer l’espace mémoire pour chaque ligne et garder la référence de chacune de ces lignes dans un tableau de pointeur. Ce tableau de pointeur doit aussi être alloué dynamiquement et doit être référencé par un pointeur de pointeur. La figure suivante permet de mieux comprendre ce concept. On y retrouve un tableau d’entier de 5 par 15.
Voici un exemple de code qui permet d’allouer un tel tableau.
int** Tableau2D = NULL;
int DimensionX = 15;
int DimensionY = 5;
int i;
/* Alloue le tableau de pointeur d’entier */
Tableau2D = (int**) malloc(sizeof(int*) * (DimensionX));
/* Alloue chacun des espaces contigus du tableau d’entier */
for (i = 0; i < DimensionX; i++) {
Tableau2D[i] = (int*) malloc(sizeof(int) * (DimensionY));
}
Il ne faut pas oublier qu’après l’allocation dynamique de la mémoire, il est important de libérer la mémoire. Voici un exemple de code qui vous permettra de libérer la mémoire associée à ce tableau.
/* Libere l’espace mémoire des entiers */
for (i = 0; i < DimensionX; i++) {
free(Tableau2D[i]);
}
/* Libere l’espace memoire des pointeurs d’entier */
free(Tableau2D);
/* Met le pointeur a nul */
Tableau2D = NULL;
Le tableau que vous allez créer sera constitué de deux parties. La première contiendra les caractères à afficher à l’écran : ce sera donc une représentation interne de l’affichage de l’état courant de la partie. La deuxième contiendra l’information réelle de la grille de jeu, c’est-à-dire la position des mines et des nombres indicateurs. Voici les valeurs suggérées
à utiliser pour les données entières : -1 pour une mine, 0 pour une case vide et non- contiguë à une mine et 1 à 8 pour une case contiguë au nombre de mines indiquées. Pour mettre en pratique certains outils de programmation, vous devez créer une structure de données qui contiendra un caractère (char) pour la première partie et un entier (int) pour la deuxième partie. Ainsi, le tableau que vous allez créer sera de ce type. Voici comment déclarer un tel type :
typedef struct {
int Info; /* 0 = libre 1 a 8 = le nombre de mine parmis les 8 voisins -1 = mine */
unsigned char Display; /* Le caractere qui est affiche a l'ecran */
} CaseChampMine;
6. La variable qui identifiera le niveau de difficulté que le joueur aura choisi doit être d’un type que vous devez définir. Ce type doit être défini comme un type énuméré. Par exemple :
enum NiveauDifficulte {ndTresFacile, ndFacile, ndMoyen, ndDifficile, ndTresDifficile};
7. Aucune de vos fonctions n’aura plus de 25 lignes de code incluant la fonction principale « main » (en excluant les commentaires). De plus, vous devez créer au moins une fonction pour laquelle vous utilisez le passage de paramètres par référence.
8. Lorsque vous explorez une case libre de la grille de jeu, vous devez lancer un algorithme qui permettra d’identifier toute la zone de case libre contiguë à la première. Cet algorithme doit identifier les cases libres mais s’arrêter sur les contours de région libre définis par les numéros qui identifient le nombre de mines sur chaque case (de 1 à 8). Pour résoudre ce problème, vous devez créer une fonction récursive.
9. Vous ne devez utiliser aucune variable globale 10. Votre code doit être lisible et bien documenté.
Évaluation
L’évaluation de ce laboratoire se fera par la remise d’un rapport à la période qui suit la quatrième période allouée à ce laboratoire. Le rapport doit contenir un organigramme général du déroulement de votre programme (une page). Ensuite, vous devez aussi remplir la grille d’évaluation de la page 8. Finalement, répondez aux questions suivantes, sur une à deux pages.
Quelle est la pertinence de la structure de données utilisée dans ce laboratoire? En quoi cette structure est-elle adaptée ou non au problème de la gestion du contenu et de l’affichage d’une grille? Donnez les avantages de la structure de données imposée pour ce problème. Parlez de modifications que vous apporteriez à la structure de données pour l’améliorer. (15)
Soit un changement aux spécifications du jeu. Pour une difficulté additionnelle, il arrive qu’une ligne ou une colonne complète (parsemée aléatoirement de cases libres ou de mines) soit insérée à quelque part dans la grille, et ce pendant une partie en cours! L’ajustement des chiffres indiquant la quantité de mines voisines dans les cases adjacentes à cette nouvelle ligne ou colonne est effectué tout de suite après l’insertion. Proposer une façon de faire une modification à la structure de données pour faciliter l’implémentation de cette nouvelle option. (10)
Après des ventes incroyables, votre logiciel a besoin de nouveauté pour continuer à conquérir le cœur du public. Un collègue propose une idée révolutionnaire : des cases hexagonales! Proposez une méthode ou une modification à la structure de données qui permettrait la réalisation de cette nouvelle grille. (5)
La remise se fait par un fichier ZIP correspondant aux éléments suivants :
Le dossier principal de votre projet Visual C++ incluant tous ses dépendants (sauf les librairies principales du C/C++). N’oubliez pas de bien documenter votre code source.
Une version exécutable de votre programme.
Un PDF de votre rapport.
Le fichier doit être nommé : GPA665_LAB1_Demineur_VotreNom.ZIP Le tout doit être remis par courriel au chargé de laboratoire avant la date prescrite.
Grille d’évaluation
En guise d’autoévaluation, imprimez et remplissez vous-même cette section. Mentionnez une référence (nom de fichier et numéro de ligne) lorsque demandé pour faciliter la vérification par le correcteur.
Spécifications techniques Oui Non Référence (fichier, ligne) 2.5 Options offertes sur la taille de la grille _____________________
2.5 Différentes difficultés offertes _____________________
5 Affichage correct de la grille _____________________
5 Comportement attendu du jeu _____________________
5 Fin de la partie _____________________
Spécifications de programmation Oui Non
5 Structures de données imposées : tableau 2D, CaseChampMine, NiveauDifficulte
_____________________
_____________________
5 Gestion dynamique de la mémoire et
libération de l’espace alloué _____________________
5 Utilisation de fonction avec passage de
paramètre par référence _____________________
5 Utilisation d’une fonction récursive pour
l’exploration des cases de la grille _____________________
(-10) Aucune variable globale
Qualité logicielle T.B. Bon Pauvre Référence (fichier, ligne) 5 Modularité : usage généralisé de fonctions
et regroupement logique en modules
_____________________
_____________________
5 Robustesse : Précaution pour éviter les problèmes de données erronées, etc.
_____________________
_____________________
5 Documentation : Commentaires pertinents qui accélèrent la compréhension du code
_____________________
_____________________
5 Clarté du code : Code concis et court utilisant les fonctions adaptées
_____________________
_____________________
60 TOTAL
