Projet Pacman

Langage C
Projet
[email protected]
1
Introduction
Le but de ce projet est de programmer un petit jeu de pacman simplifié. Ceci est un
projet pédagogique, donc certaines structures de données ou certains algorithmes sont
imposés.
Voici par exemple une version du résultat attendu :
1
2
Travail demandé et organisation
Etape 1 : création d’un plateau de base
Tout d’abord vous allez créer un fichier “Plateau.h” dans lequel vous allez définir une
énumération Case contenant :
• mur,
• vide,
• piece,
Vous pouvez utliser un typedef afin d’avoir une déclaration de l’énumération plus
lisible. Une Case correspond aux différents objets qu’il pourra y avoir sur la grille.
Nous complèterons par la suite cette énumération avec de nouveaux objets.
Ensuite vous devez définir une structure représentant le Plateau de jeu contenant :
• Un entier : tailleX
• Un entier : tailleY
• Un entier : NbPieces
• Un entier : nbMurs
• Un double pointeur sur une Case : grille
La encore nous complèterons cette structure par la suite.
Ensuite vous devez définir les deux fonctions suivantes :
• creerPlateau qui renvoie un pointeur sur un plateau et qui prend en paramètre
4 entiers (correspondants aux tailles X et Y, au nombre de pièces présentes sur
la grille et au nombre de murs). Vous devez affecter les différents attributs d’un
plateau, en pensant bien à faire les réservations mémoires nécessaires. La grille
sera plus grande que celle définie par l’utilisateur : en effet un mur sera rajouté
tout autour de celle-ci. L’intérieur de la grille sera vide.
• afficherPlateau qui ne renvoie rien et qui prend en paramètre un pointeur sur un
plateau constant. La fonction doit afficher une grille avec un ’#’ pour un mur, ’*’
pour une pièce et un espace pour une case vide.
Enfin vous allez définir dans un fichier “main.c” un programme principal afin de
tester ces deux fonctions.
Etape 2 : Ajout d’une gestion de l’aléatoire
Vous devez maintenant créer deux fichiers “Alea.h” et “Alea.c”. Dans le fichier H, vous
devez définir la signature suivante : int entierAlea_a_b(const int a, const int b). Dans
le fichier C, définissez la fonction qui doit générer aléatoirement un entier entre a et b.
Ajouter l’initialisation de la graine dans le programme principal (comme vu en TP).
2
Etape 3 : Ajout des pieces de façon aléatoire
Créer une fonction void ajouterPieces(Plateau *) qui va aléatoirement ajouter les pieces
sur la grille. La fonction doit tirer aléatoirement un X et un Y et ajouter une pièce à
l’emplacement (X,Y) si la case est vide, sinon il faut rechoisir un emplacement aléatoire. Il faut répéter cette opération autant de fois qu’il y a de pièces.
Ajouter un appel à cette fonction à la fin de la fonction creerPlateau.
Etape 4 : Ajout des murs de façon aléatoire
La gestion des murs va être plus compliquée. Afin de rendre le code plus lisible vous
allez créer deux fichiers “Mur.h” et “Mur.c”.
Ensuite créer une fonction int voisinsSansMurs(const Plateau *, int x, int y) qui va
vérfier si tous les voisins de la case en (x,y) ne sont pas des murs. La fonction renvoie
1 si aucun voisin n’est un mur, 0 sinon. Les murs appartenant aux bords sont ignorés.
Créer également une fonction int estUnCoin(const Plateau *, int x, int y) qui retourne 1 si le point en (x,y) est un coin et 0 sinon (un coin à l’intérieur des bords du
plateau ; par exemple (1,1) est un coin).
Créer une fonction void rechercherPtDepart(const Plateau *, int *x, int *y, int
*dirX, int *dirY). Dans cette fonction vous devez :
• Choisir un côté de départ aléatoirement.
• En fonction du côté, choisir aléatoirement un x/y de départ (qui ne soit pas dans
un coin, et qui colle un des bords du plateau). La direction est automatique en
fonction du côté.
• Recommencer le processus tant que la case choisie possède un voisin “mur”.
Créer une fonction int tailleMax(const Plateau *, int x, int y, int dirX, int dirY) qui
va calculer la taille maximum qu’un mur peut avoir. Un mur peut être construit tant
que la case courante est vide et qu’elle ne possède pas de voisin.
Créer ensuite une fonction void construireUnMur(Plateau *, int x, int y, int dirX,
int dirY, int longueurMax) qui va choisir une taille aléatoire entre 1 et longueurMax et
qui va construire le mur sur le plateau (en fonction des paramètres).
Maintenant que vous avez une fonction permettant de construire aléatoirement un
mur, créer une fonction void ajouterMurs(Plateau *) qui va faire nbMurs appels à la
fonction précédente.
Enfin, ajouter un appel à cette dernière fonction à la fin de la fonction creerPlateau.
Etape 5 : Ajout d’un joueur humain
Dans un fichier Humain.h créer une structure Humain composée de :
3
• Un nom,
• un score,
• un record (de points),
• une positionX,
• une positionY.
Dans un fichier Humain.c créer les fonctions suivantes :
1. void afficherHumain(const Humain *) qui va afficher un joueur humain (nom,
score dans la partie actuelle, et son record (“aucun record” s’il n’en a pas)).
2. void recupererRecord(Humain *) qui va ouvrir le fichier “nomDuJoueurHumain.record”
et qui va stocker le record du joueur passé en paramètre.
3. void sauverRecord(const Humain *) qui va ouvrir le fichier “nomDuJoueurHumain.record” et qui va écrire son record dans le fichier.
4. Humain *creerHumain() qui va créer un joueur humain. Le nom est saisi au
clavier et le record est chargé à l’aide de la fonction définie précédemment et le
score et les positions sont initialisés à 0.
Ensuite modifier dans le fichier “Plateau.h” l’enumération pour y rajouter “humain”. Dans la fonction affichierPlateau du fichier “Plateau.c” ajouter l’affichage pour
l’humain : “H”.
Etape 6 : Création du jeu
2.1
Initialisation du jeu
Dans un fichier “Jeu.h” vous allez créer une structure Jeu contenant :
• Un pointeur sur un plateau,
• un pointeur sur un humain.
et une fonction void afficherJeu(const Jeu *) qui affichera un plateau et en dessous le
joueur humain. Créer également une fonction Jeu *creerJeu(int tX, int tY, int nbP, int
nbM) qui va créer un jeu (créer un plateau puis un humain).
Dans un fichier “Jeu.c” implémentez ces fonctions.
Définir ensuite une fonction void initialiserJeu(Jeu *j) qui va placer aléatoirement
le joueur humain sur le plateau.
4
2.2
Déplacement du joueur humain
Il va maintenant falloir gérer les déplacements possibles pour le joueur humain. Pour
des raisons pédagogiques, les déplacements du joueur humain se feront à l’aide d’une
liste chainée. Commencer donc par créer un fichier “ListeChainee.h” (puis respectivement son .c) afin de gérer une liste chainée. Créer une structure chainée Coup contenant deux entiers (position en X et position en Y) et un pointeur sur un coup (pour le
chainage).
Ensuite définir les fonctions int compareCoups(const Coup *, const Coup *), int
coupExiste(const Coup *, const Coup *) et void afficherCoupsPossibles(const Coup *).
Faire une fonction Coup* choixCoup(Jeu *j) qui va créer la liste des coups possibles (parmi haut/bas/gauche/droite) et qui va demander à l’utilisateur de choisir une
direction (z/s/q/d) et qui va retourner le coup correspondant s’il est valide.
Créer la fonction void jouerCoup(Jeu *, Coup *) dans le fichier “Jeu”. Cette fonction met à jour le plateau après avoir joué le coup passé en paramètre. La fonction doit
également mettre à jour le score du joueur s’il prend une pièce.
Enfin créer une fonction void jouer(Jeu *) qui va initialiser le jeu, puis tant que la
fin de partie n’est pas atteinte va :
• afficher le jeu.
• Faire choisir le coup au joueur.
• Jouer le coup.
Etape 7: ajout des fantômes
Afin de rendre le jeu plus difficile nous allons maintenant rajouter des fantômes sur le
plateau. Dans le fichier “Jeu.h” rajouter une structure Fantome comprenant les deux
entiers pour les positions X et Y.
Vous devez donc également modifier :
• L’énumération Case pour rajouter “fantôme”.
• L’affichage d’un plateau pour rajouter “F” si un fantôme est présente sur une
case.
• Le nombre de fantômes sera pris en dernier argument du programme principal.
• La fonction creerJeu prend également en paramètre le nombre de fantômes afin
de créer un tableau dynamique. Pour cela rajouter dans la structure Jeu un pointeur sur un fantôme. Il est également conseillé de stocker dans la structure le
nombre de fantômes.
• Dans la fonction initialiserJeu remplisser aléatoirement le tableau de fantômes
et les rajouter sur la grille.
Pour une gestion simplifiée, les fantomes vont se déplacer aléatoirement. Créer
une fonction bougerFantomesAleatoirement qui va bouger chaque fantome d’une
5
case aléatoirement (parmi haut/bas/gauche/droite). Le fantome ne peut bouger
que si la case d’arrivée est vide ou correspond au placement du joueur humain.
Cette fonction doit être appelée dans la boucle de jeu.
Fin et bonus
Quelques remarques:
• Pensez à récupérer le record du joueur lors de l’initialisation du jeu.
• Pensez à sauver le record du joueur si besoin lors de la fin de jeu.
• Si une pièce est prise par le joueur humain, il faut incrémenter son score et enlever la pièce du plateau.
• S’il n’y a plus de pièces présentes sur le plateau, la partie s’arrête et le joueur
humain a gagné.
Améliorations possibles:
• Ajouter de la couleur à l’affichage.
• Faire des murs qui ne partent pas que du bord.
• Ne plus avoir à taper “entrer” lors de la saisie de coup.
6