[TP] Pendu

Introduction du cours

Bienvenue ! Le but de ce tutoriel est de créer un Pendu comme dans le tuto de M@teo21 sauf qu'il sera réalisé en SDL.

Avant de commencer à lire ce tutoriel, vous devez avoir lu celui de M@teo21 jusqu'au chapitre 8 soit le chapitre sur SDL_ttf.

L'intérêt de ce tutoriel est de créer un programme en SDL avec l'utilisation de la bibliothèque SDL_ttf. Si vous venez de lire le tuto sur SDL_ttf, alors le jeu du pendu est un très bon exercice. Et même si vous savez utiliser SDL_ttf, venez tout de même faire un pendu !!

N'attendons pas plus longtemps, c'est parti !

ObjectifsREGLES DU JEU

Pour ceux qui n’auraient pas compris, on veut créer un pendu en SDL.
Hop, un petit rappel des règles pour que l'on fasse le même jeu. Le but est de trouver un mot qui est masqué. Le joueur va donc essayer de découvrir le mot en tapant une lettre. Cependant, le joueur n'a que sept essais. En effet, si le joueur tape un A et que le mot secret en contient effectivement, le joueur ne perd pas d'essais et on découvre tous les A du mot secret. Cependant, si le mot ne contenait pas de A, le joueur perd un essai. Voilà un petit rappel du jeu.

Mais pourquoi on appelle-t-on ce jeu le pendu ?

Car à chaque fois que le joueur perd un essai, un dessin se complète en formant un bonhomme en train de se faire pendre ! sisi !!
En effet, lorsque vous avez réalisé le pendu en console, je ne crois pas que vous aviez envie de créer un petit bonhomme rien qu'avec des | , / , et \ surtout quand vous êtes justement arrivé à la fin de la partie II.

Je vous donne tout de suite quatre écrans obtenus. L'objectif est de réaliser un pendu qui ressemble plus ou moins à cela.

Comme vous pouvez le voir, il y a deux versions de pendu. Et oui, comme tout tutoriel qui se respecte, je vais vous donner à la fin de celui-ci quelques améliorations que vous pourrez faire. Les deux images du dessus représentent le pendu que nous allons réaliser. Les deux autres images représentent le pendu avec les améliorations.

REALISATIONS

Voici les images dont j'ai eu besoin. Je tiens à signaler que je n'ai pas un très bon niveau avec photoshop.

Ne dites rien sinon je vais me vexer et gare à vous .

J'ai créé un fichier zip avec toutes les images, cela vous fera gagner un peu de temps. Mais rien ne vous empêche de créer vos propres images... J'ai aussi rajouté un dictionnaire de plus de 22 000 mots en majuscule avec un retour à la ligne entre chaque mot. Enfin, j'ai ajouté trois polices.
De plus, je me suis permis de rajouter le mot "ZERO" qui me semble tout à fait approprié dans ce dictionnaire.

Télécharger le pack d'image.

Comme vous le voyez sur les images, mon pendu est constitué de deux parties. À gauche le mot secret et en dessous de lui les lettres qui ont déjà été essayées, puis à droite on a les images. Vous pouvez voir sur la capture d'écran que les lettres en dessous du mot secret sont classées dans l'ordre alphabétique. Vous pouvez très bien modifier cela, mais la correction sera adaptée à cette copie d'écran.

Maintenant, vous avez deux choix :

• Soit vous commencez à coder le jeu tout de suite. Alors ne lisez pas plus loin.

• Soit vous vous aidez de ce que vous avez fait lorsque vous avez réalisé ce programme en console. Alors vous pouvez continuer. Je vous donnerais aussi quelques conseils concernant "le plan" du code à réaliser.

Je vais donc vous redonner ici les fonctions qui nous ont servi lors du précédent épisode pendu.

srand(time(NULL)); nombreMystere = (rand() % (MAX - MIN + 1)) + MIN;

On fait deux trois petits changements et on obtient une fonction qui renvoi un int au hasard entre min et max.

int nombreAleatoire(int max, int min); int main(int argc, char *argv[]) { srand(time(NULL)); intAuHasard = nombreAleatoire(10, 1500); } int nombreAleatoire(int max, int min) { return (rand() % (max - min + 1)) + min; }

N'y aurait-il pas une autre fonction qui pourrait nous aider ?

Oui. C'est bien beau d'avoir un dictionnaire mais encore faut-il trouver un mot dedans, qui plus est au hasard.
Voici donc pour vous :

int piocherMot(char *motPioche); int main(int argc, char *argv[]) { ... } int piocherMot(char *motPioche) { FILE* dico = NULL; int nombreMots = 0, numMotChoisi = 0; int caractereLu = 0; dico = fopen("sources/dico.txt", "r"); // ATTENTION à l'emplacement if (dico == NULL) // { return 0; } do { caractereLu = fgetc(dico); if (caractereLu == '\n') nombreMots++; } while (caractereLu != EOF); numMotChoisi = nombreAleatoire(nombreMots); rewind(dico); while (numMotChoisi > 0) { caractereLu = fgetc(dico); if (caractereLu == '\n') numMotChoisi--; } fgets(motPioche, 100, dico); motPioche[strlen(motPioche) - 1] = '\0'; fclose(dico); return 1; }

La fonction piocherMot renvoi 0 si elle n'arrive pas à charger le dictionnaire et renvoi 1 si tout se passe bien. Elle prend en paramètre un tableau de chars.

Je tiens à signaler que l'objectif n'est pas de créer un pendu mais bien de créer un pendu EN SDL. Je suppose donc que vous avez déjà compris ces deux fonctions lors des deux premières parties du tutoriel de M@teo21. Si ce n'est pas le cas, on retourne voir son cours : nombre aléatoire et lire et écrire dans un fichier.

Plan du code

Vous ne savez pas comment démarrer ? Vous n'arrivez pas à visualiser le code avant de vous lancer sur votre IDE ?
Pas de problème. Voici comment j'ai fait pour réaliser ce code.

• Première étape : le squelette. Il faut créer le code de base : afficher une fenêtre, insérer les deux fonctions ci-dessus, prévoir la place du switch qui gère les évènements...

• Deuxième étape : Création des variables. Cette étape permet de visualiser votre futur code. Si vous connaissez le nombre et le type de variables que vous avez besoin, alors vous pouvez vous lancer. Cette étape est vraiment importante car elle permet de représenter plus ou moins le fonctionnement de votre programme.

• troisième étape : la boucle des évènements.

• quatrième étape : Le contenu.

  • Dans un premier temps, il faut s'assurer que le joueur a bien tapé une lettre, et aussi qu'il ne l'avait pas déjà essayé. Il vous faudra donc explorer un tableau de 26 caractères pour s'en assurer. Vous pourrez par exemple réaliser ceci à l'aide de 2 conditions de type if.

  • A partir de maintenant, le joueur tente une lettre. Il vous faut donc gérer le nombre de ses essais. Petit rappel, si le joueur a trouvé au moins une lettre, on ne lui retire pas son essais.

  • Le nombre d'essais étant fixé, on peut donc définir l'image à blitter, et aussi savoir si le joueur a gagné, a perdu, ou peut encore continuer à jouer.

  • On blitte tout ! Le texte (le mot secret, les lettres déjà essayées, ...), mais aussi les images. Vous devrez blitter différentes choses si le joueur a gagné ou a perdu.

• Et on n'oublie pas de libérer la mémoire.

Et voila, maintenant c'est à vous de travailler.
Bon courage les Zéros !!!

Correction

Fini ou pas fini, si vous lisez ces lignes, c'est parce que vous voulez la correction. Et justement elle arrive !
Pour des raisons pratiques j'ai préféré n'utiliser que le fichier main.c. Mais rien ne vous empêche de mettre les deux fonctions dans un .h et un .c et de recréer d'autres fonctions.
Voila comment on va procéder. Je vais découper mon code en plein de petites parties que je vais expliquer séparément. Etant donné que j'ai bien décrit l'objectif final dans la première partie, vous devriez comprendre.
Et maintenant, c'est parti !

Créer la fenêtre

Tout d'abord, on va créer une fenêtre toute simple avec les deux fonctions que j'ai donné dans la partie "objectifs". On inclut d'avance SDL_ttf car on en aura besoin. N'oubliez pas de linker votre bibliothèque pour pouvoir utiliser SDL_ttf.

#include <stdlib.h> #include <stdio.h> #include <string.h> #include <SDL/SDL.h> #include <time.h> #include <SDL_image.h> #include <SDL/SDL_ttf.h> int piocherMot(char *motPioche); int nombreAleatoire(int nombreMax); int main(int argc, char *argv[]) { SDL_Surface *ecran = NULL; SDL_Event event; srand(time(NULL)); int continuer = 1; SDL_Init(SDL_INIT_VIDEO); ecran = SDL_SetVideoMode(750, 320, 32, SDL_HWSURFACE | SDL_DOUBLEBUF); TTF_Init(); SDL_WM_SetCaption("Pendu en SDL pour les Zeros", NULL); while (continuer) //Boucle des évenements { SDL_WaitEvent(&event); switch (event.type) { case SDL_QUIT: continuer = 0; break; case SDL_KEYDOWN: switch (event.key.keysym.sym) { case SDLK_ESCAPE: continuer = 0; break; default: break; } SDL_Flip(ecran); } } TTF_Quit(); SDL_Quit(); return EXIT_SUCCESS; } int piocherMot(char *motPioche) { FILE* dico = NULL; int nombreMots = 0, numMotChoisi = 0; int caractereLu = 0; dico = fopen("sources/dico.txt", "r"); if (dico == NULL) // { return 0; } do { caractereLu = fgetc(dico); if (caractereLu == '\n') nombreMots++; } while (caractereLu != EOF); numMotChoisi = nombreAleatoire(nombreMots); rewind(dico); while (numMotChoisi > 0) { caractereLu = fgetc(dico); if (caractereLu == '\n') numMotChoisi--; } fgets(motPioche, 100, dico); motPioche[strlen(motPioche) - 1] = '\0'; fclose(dico); return 1; } int nombreAleatoire(int nombreMax) { return (rand() % nombreMax); }

Ce code nous permet donc d'ouvrir une fenêtre et de la refermer en appuyant sur ECHAP. Rien de bien passionnant mais ce code va nous servir de base.
Avant de commencer, il va falloir que vous téléchargiez le même pack d'images que moi.

Télécharger le pack d'image Images_Dico_Polices.zip.

Quelques variables

Premièrement, on crée un define et une énumération anonyme qui vont nous être utiles dans la suite du code.

#define NOMBRE_ESSAIS 7 enum {JEU_TERMINE, JEU_EN_COURS}; // Permet de savoir si on est en train de jouer ou non enum {OUI, NON}; // Permet d'éviter de mettre des 0 et des 1

Maintenant, on va compléter le code en rajoutant des variables. Je vais donner toutes les variables d'un coup de façon à ne pas tout le temps remonter jusqu'au début du code pour définir un petit nombre et redescendre encore pour mettre un petit bout de code.
Certaines variables ne vont peut-être pas être tout à fait comprises au début mais vous verrez à quoi elles servent lorsque nous les utiliserons.

SDL_Surface *ecran = NULL, *img = NULL; // On créé 2 surfaces pour le texte et pour l'image SDL_Event event; // Evenement int continuer = 1; srand(time(NULL)); // pour le nombre aléatoire char lettrePropose = '\b'; // on va stocker ici la lettre tapée char motMystere[50]; // Le mot mystère à découvrir if ( piocherMot(motMystere) == 0 ) // on demande un mot qui sera mis dans motMystere return EXIT_FAILURE; // si on n'a pas réussi à charger le dictionnaire on arrête le programme const int tailleMot = strlen(motMystere); char *motMystereEnCours = NULL; // Allocation dynamique de la mémoire motMystereEnCours = (char *) malloc(tailleMot * sizeof(char)); if (motMystereEnCours == NULL) // Verification de l'allocation de mémoire return EXIT_FAILURE; // On arrête tout strcpy(motMystereEnCours, motMystere); // on copie le mot mystère dans une autre chaine char tableauDeSaugegardeDesLettresTape[] = " " ; // 26 caractères on retient les lettres que le joueur a tapé int nombreEssais = NOMBRE_ESSAIS; int reussi = JEU_EN_COURS; // Permet de savoir si le joueur à découvert le mot, on pourra aussi lui demander si il veut recommencer une autre partie int nombreEssaisRajoute = 0; // Cette variable a un rapport avec le nombre d'essais. int sauterUnTour = NON; // Cette variable permet de sauter le tour du joueur si il tape une lettre une seconde fois int numeroDeLaLettre = 0; // Le numéro de la lettre permet de dire que A = 1 , B = 2 , . . . Elle est utilisée pour afficher les lettres que le joueur a déjà tapé int i = 0;

Pour les noms de variables, j'ai essayé d'être le plus clair possible. Il y a de multiples possibilités pour coder ce programme. Personnellement, j'ai choisi de créer deux chaines de caractères. L'une contient le mot à découvrir (motMystere) et l'autre est la copie codée de ce mot.

C'est-à-dire qu'au début de la partie, elle sera composée de *. L'avantage de cette technique est qu'on ne doit pas s'embarrasser de ce qu'on affiche. Dans la suite, on modifiera cette chaine de caractères puis on l'affichera simplement à l'écran.

Petit remarque, j'ai fixé la longueur des tableaux à 51 caractères car l'un des mots le plus long en français est hexakosioihexekontahexaphobie (peur du nombre 666). Celui-ci ne comporte que 29 lettres. Vous avez aussi dans le même genre le mot hippopotomonstrosesquippedaliophobie (peur des mots trop longs). Celui-ci totalise 35 lettres. Bref, tout cela pour dire qu'il nous restera encore de la place dans le tableau.

• La surface img va permettre d'afficher les différentes images à droite.

• lettrePropose va contenir la lettre que le joueur tape. On l'initialise simplement grâce à '\b'.

• motMystere est le mot secret à découvrir.

• Les deux lignes suivantes permettent d'utiliser la fonction piocherMot. Elle arrêtera le programme si on n'a pas réussi à charger le dictionnaire.

• Le tableau motMystereEnCours est une copie de motMystere. C'est lui qui sera codé et affiché tout au long de la partie.

• Ensuite, on copie le mot mystère dans l'autre chaine et on crée un int qui va retenir la taille du mot mystère.

• Le tableau tableauDeSaugegardeDesLettresTape permet l'affichage des lettres tapées en bas de l'écran. Il permet aussi de gérer la répétition d'une même lettre.

Maintenant, on a toutes les variables pour créer notre pendu. Si vous ne comprenez pas le sens de certaines variables, ce n'est pas grave. Sachez simplement que nous les avons créées. Vous comprendrez leurs utilitées lorsque nous les utiliserons.

Initialisation

On va maintenant initialiser la SDL et SDL_ttf. Nous aurons besoin de trois polices (affichage du mot mystère, affichage des caractères, affichage de la phrase à la fin du jeu), d'une couleur noire, et de deux positions (image et texte).
C'est parti !