Projet: Jeu mémoire

Langage C
Safwane BENIDIR
Vincent GRANET
Wail BENLEMLIH
Ricardo BARRIGA
 Sommaire

Introduction .................................................................................................... 2
Répartition des tâches ................................................................................... 2
Gestion des fichiers ........................................................................................ 2
Explication des fonctions principales ............................................................. 3
Choix des variables et structures ................................................................... 4
Problèmes rencontrés .................................................................................... 5
Affichage du jeu ............................................................................................. 5
Fenêtre principale ....................................................................................... 5
Deuxième fenêtre ....................................................................................... 6
Troisième fenêtre ........................................................................................ 6
Quatrième fenêtre....................................................................................... 6
Cinquième fenêtre Score............................................................................. 7
Conclusion ...................................................................................................... 7
Introduction

Ce projet a pour but de proposer à l’utilisateur un jeu de mémoire. Le

jeu se présente avec un certain nombre de cartes face caché. Le but du jeu est
de retourner toutes les cartes. Au début le joueur choisit une carte, la carte se
retourne. Le joueur choisit alors une autre carte. Si cette dernière et comme la
première les deux cartes reste visibles sinon les deux cartes reprennent leur
forme initiale. Le jeu se termine quand l’utilisateur a réussi à trouver toutes les
paires de cartes. Il pourra voir son score et le comparer à ceux
des autres joueurs.
Afin de réussir ce projet de langage C, il a été demandé d'utiliser la bibliothèque
d'interface graphique libsx qui ne peut être compilée que sur LINUX. Tout
d'abord nous avons été amené à faire une étude des différentes fonctions que
nous propose la librairie libsx, et à partir de cela, nous avons identifié les
avantages et les contraintes à respecter. Nous traiterons dans ce rapport
essentiellement l’aspect structurel, logique, et algorithmique du programme.

Répartition des tâches

Plusieurs jours de travail ont été nécessaires pour finaliser ce jeu et prendre
en compte toutes les exceptions possibles lors de l’exécution.
La première partie du travail a été de penser le programme. Cette étape sur
papier nécessite de penser au règlement du jeu, d’imaginer ainsi que
d’organiser la structure du programme afin qu’il suive un mécanisme
simple, clair et fiable. On déduit ainsi les constantes invariantes du
programme, les variables principales évoluant avec le jeu (comme le score),
et les fonctions à traiter séparément pour une plus grande clarté. Pour
chaque fonction, on appréhende les variables, la valeur de retour, et le
travail à réaliser.
La seconde partie fut la documentation, afin de reprendre les notions
essentielles pour travailler, comme le fonctionnement des tableaux, des
chaînes de caractères, et une première approche des pointeurs. Il fut
également important de réviser les bases syntaxiques du langage C.
La troisième partie fut de développer le programme sur ordinateur et de
répartir les tâches au sein du groupe.
La gestion du menu principale et la récupération des données a été
principalement réalisé par Wail.
La majeure partie des différentes fonctions nécessaires au fonctionnement
du jeu ont été réalisé par Safwane.
La gestion du score et l’interface de son affichage a été réalisé par Ricardo.
Gestion des fichiers

score.h
callbacks.c
Mémoire.c
callbacks.h

data.c
data.h score.c

jeu.c jeu.h

memoire.c :
Ce fichier est le principal. On va créer la fenêtre principale où le joueur
pourra commencer le jeu. Ce fichier va utiliser les fonctions des fichiers
score.c, callbacks.c et data.c.

callbacks.c :
Ce fichier contient les fonctions de la deuxième fenêtre où on pourra choisir
le nombre de cartes et le niveau de difficulté. Aussi dans ce fichier on va
créer le tableau du jeu. Il va utiliser des fonctions des fichiers score.c et
jeu.c.

data.c :
Ce fichier gère l’enregistrement des textes dans les structures pour les
cartes.

score.c :
Ce fichier va récupérer le nom du joueur, faire la gestion de score, lire et
écrire dans un fichier texte. Il va appeler le fichier data.c

jeu.c :
Ce fichier contient des fonctions pour tester s’ils sont égaux et la gestion du
temps pour le niveau de difficulté. Aussi il gère les couleurs à mettre quand
les cartes sont tournées.
callbacks.h, data.h, score.h et jeu.h sont des fichiers qui contiennent des
prototypes des fonctions et définitions des structures.
Explication des fonctions principales

Cette fonction est définie dans le fichier jeu.h et est utilisée dans le fichier
callbacks.c quand on a fini le jeu. Dans cette fonction on va enregistrer le
score du joueur dans la structure SCORE et on va l’afficher dans une fenêtre
« vous avez gagné » qui va apparaitre quand on a gagné. Dans cette même
fenêtre on va créer le bouton Rejouer, Exit et Voir le classement. Ce dernier
bouton va appeler la fonction calc_core().

Cette fonction est définie et utilisée dans le fichier jeu.h. Elle est appelée
quand on clique sur le bouton facile. Dans cette fonction on va définir le
temps pendant lequel les cartes vont rester tournées. On va aussi récupérer
la taille du tableau à jouer que l’utilisateur souhaite. On va aussi appeler la
fonction créer_jeu(JEU_DE_CARTES,d->nbcarte). On va initialiser à 0 le
tableau ETAT_BOUTON et lancer une nouvelle fenêtre avec les cartes. Pareil
pour les fonctions jouer_moyen et jouer_difficile avec un temps différent.

Cette fonction est définie et utilisée dans le fichier jeu.c. Elle va utiliser les
fonctions setTexte(d,JEU_DE_CARTES[courant]) pour enregistrer dans la
variable texte de la structure Carte le texte du tableau JEU_DE_CARTES.
Aussi elle va mettre ce texte dans le bouton courant.

Ce fonction est définie dans le fichier jeu.c et est utilisée dans le fichier
callbacks.c. Dans cette fonction on va tester si la carte a été déjà
découverte ou pas. Pour le faire on appelle la fonction Carte_traitee(int i) qui
va retourner la valeur du tableau ETAT_BOUTON[i]. Si c’est pas une carte
découverte on va afficher la carte et garder la valeur avec la fonction :
memoriser(d,d->Texte,w,courant)
Cette fonction est définie dans le fichier callbacks.c. Elle est appelée quand
on clique dans le bouton START. Cette fonction va lancer une nouvelle
fenêtre « Option du jeu ». Dans cette fenêtre on va placer les boutons
FACILE, MOYEN, DIFFICILE et on va mettre une zone pour que l’utilisateur
puisse rentrer la taille du tableau qu’il souhaite jouer.

Le but de cette fonction et de rendre les positions des cartes le plus carré
possible, par exemple si le nombre de carte était de 30 au lieu de mettre 15
colonnes et deux lignes cette fonction met 6 lignes et 5 colonnes.

Cette fonction permet de savoir si toute les cartes sont retournées ou pas
afin de déclarer la fin de la partie.

Cette fonction permet de comparer les deux cartes choisies et de détecter si

la carte et déjà retournée ou bien cachée afin de ne pas perdre le compte
du score.

Cette fonction qui existe dans le fichier score.c et la fonction principale dans
la gestion de score.
Afin d’afficher les dix premiers scores dans un label cette fonction récupère
les ancien score mis dans le fichier et insère le score courant dedans ensuit
elle les affiches.

Cette fonction permet de décrémenter le compteur.

Cette fonction permet de créer les boutons elle commence tous d’abord
par appelé la fonction decomposer_produit afin de déterminer le nombre de
colonne ensuit et elle crée les boutons et les placée.

Cette fonction permet d’initialiser les cartes et affecte à chaque binôme de

carte un animal aléatoirement.
Choix de variables et structures

Structure Carte :

La structure Carte est dans le fichier data.h. Dans cette structure carte on
trouve un widget pour récupérer la taille du jeu souhaité. La variable
nbCarte va garder la taille du tableau. Le Texte et Texte_Precedent vont
être les chaines de caractères de chaque pair de cartes à comparer. On a
déclaré aussi un tableau global de type widget pour dessiner tous les cartes.

Structure Score :

La définition de la structure SCORE est dans le fichier score.h. Cette

structure assemble le nom du joueur et son score. On a créé un tableau
global de type SCORE pour gérer les 10 meilleurs joueurs.

Variables du fichier jeu.h :

  Variable compteur : Elle va augmenter dans chaque click et
diminuer si c’est une carte déjà traitée ou si on trouve deux cartes
différentes. Ce variable va servir à tester si c’est le premier click ou
pas avec la fonction C_est_le_premier_click(int *compteur). Quand on
initialise le jeu on le remet à 0.

 Variable attendre : elle reçoit true ou false. Elle sert à gérer le

temps pendant lequel on affiche les cartes.

 Tableau ETAT_BOUTON[] : Il va enregistrer l’état du bouton, soit 1

ou 0 si le bouton est découvert ou pas respectivement. On met à un
élément si deux cartes sont pareils. Quand on a fini le jeu on va
comparer le total de la somme des éléments de ce tableau au
nombre de cartes. Si c’est pareil ça veut dire qu’on a fini le jeu.

 Variable niveau : Elle enregistre soit 1000, 500 ou 200 qui est le
temps en millisecondes pendant le qu’on affiche les cartes.

 Variable Score : Elle va augmenter à chaque fois qu’on fait un click

et diminuer si c’est une carte déjà traitée.

 Tableau JEU_DE_CARTES[] : Il va contenir les noms des animaux

déjà mélanges.

 Tableau animal[] : Ce tableau récupère les noms des animaux du

tableau anima[] et sert pour mélanger les noms à donner au tableau
JEU_DE_CARTES.

Problèmes rencontrés
On a trouvé des problèmes pour récupérer le nom du joueur si on le
demande au tout début du jeu. C’est pour ça qu’on demande le nom à la fin
du jeu. Aussi on trouve que le score ne va pas dépendre du niveau de
difficulté ou de la taille du jeu, ce qui fait qu’on compare le score des
joueurs et ce qui a le moins de clicks est le premier dans le 10 meilleurs. On
a trouvé un problème pour recommencer le jeu pour réinitialiser les
variables.

Affichage du jeu
Fenêtre principale
Deuxième fenêtre : Choix du niveau du jeu(temporisation) et choix de la
taille du tableau à jouer.

Troisième fenêtre :

Quatrième fenêtre : Vous avez gagné. On demande le nom du joueur

après avoir gagné et avec le bouton Voir le classement on pourra voir notre
classement par rapport aux autres joueurs. On pourra aussi clicler sur
Rejouer ou Exit.

Cinquième fenêtre : Score

Conclusion
Ce projet nous a permis mettre en place tous les connaissances acquises
pendant le cours de langage C. Ce projet a été un défi pour nous. Tout
d’abord, il a été primordial comprendre les fonctions de la librairie libsx.
Ensuite on a dû repartir en différentes tâches pour qu’on puisse avancer
plus rapidement le projet, mais cela n’a pas empêché de nous aider entre
nous. On a compris que c’est mieux de tester des sous-parties d’abord et
après les implémenter dans notre code. Ce projet nous a permis aussi
découvrir des nouveaux techniques de codage et implémenter plusieurs
fonctions et fichiers afin de rendre le code plus lisible.