Jeu Motus C

Conception et réalisation du jeu Motus 2012
Proposé par Eric OBONO et Ingrid MBOPDA Page 1
TABLE DES MATIERES
INTRODUCTION GENERALE............................................................................................................. 2
CHAPITRE 1 : CAHIER DE CHARGE...................................................................................................
Introduction ...................................................................................................................................... 4
1-CONTEXTE GENERAL DU MINI-PROJET................................................................................. 4
2-PROBLEMATIQUE........................................................................................................................ 4
3-PRESENTATION DU PROJET...................................................................................................... 5
Conclusion....................................................................................................................................... 5
CHAPITRE 2 ANALYSE ET CONCEPTION.........................................................................................
Introduction ......................................................................................................................................... 6
1- ANALYSE .................................................................................................................................. 6
a-Identification des acteurs.............................................................................................................. 6
b-Besoins fonctionnels .................................................................................................................... 6
c-Besoins non fonctionnels.............................................................................................................. 6
d- Besoins optionnels ...................................................................................................................... 7
2-CONCEPTION ................................................................................................................................ 7
a-Conception générale..................................................................................................................... 7
b-Conception détaillée..................................................................................................................... 9
Conclusion..................................................................................................................................... 11
CHAPITRE 3 REALISATION DU JEU MOTUS .................................................................................
Introduction ........................................................................................................................................... 11
1-ENVIRONNEMENT MATERIEL ET LOGICIEL....................................................................... 11
2-TEST ET VALIDATION .............................................................................................................. 12
Conclusion............................................................................................................................................. 18
BIBLIOGRAPHIE ................................................................................................................................ 19
CONCLUSION GENERALE ............................................................................................................... 20

TABLE DES FIGURES
Figure 1 : diagramme hiérarchique.......................................................................................................... 9
Figure 2 : fenêtre de bienvenue ............................................................................................................. 12
Figure 3 Authentification du joueur ...................................................................................................... 13
Figure 4 Options du joueur.................................................................................................................... 13
Figure 5 : choix du nombre d’essais...................................................................................................... 14
Figure 6 choix du nombre de lettres...................................................................................................... 14
Figure 7 Grille de scores .................................................................................................................... 15
Figure 8 Fenêtre principale du jeu........................................................................................................ 15
Figure 9 Fenêtre du jeu 1....................................................................................................................... 16
Figure 10 Fenêtre du jeu 2.................................................................................................................... 16
Figure 11 Fenêtre du jeu 3..................................................................................................................... 17
Figure 12 Fenêtre du jeu 2..................................................................................................................... 18

INTRODUCTION GENERALE
Ce projet s’inscrit dans le cadre du module « mini projet programmation C », du
programme de la troisième année B de l’Ecole Supérieure Privée de l’Ingénierie et de
Technologie (ESPRIT). Ceci dans le but de nous permettre d’appliquer les connaissances
acquises en langage C dans un projet réel. Le sujet qui nous a le plus attiré est la réalisation du
jeu « MOTUS ». Le choix fait de ce jeu vient du constat fait que le besoin de distraction des
hommes devient très grandissant. En plus de cela il est très instructif dans le cadre du
développement du vocabulaire.
Le bien fondé de ce rapport est la description du jeu MOTUS, l’établissement d’un de
cahier de charge, l’analyse et la conception du jeu, ainsi que la présentation de la politique de
réalisation (c'est-à-dire les spécifications et la conception), de notre application que nous
appellerons « motus ».

Introduction
Ce chapitre va nous permettre de rédiger un cahier de charge pour notre application qui est
un document écrit visant à définir les spécifications de base d’un projet ou d’un service à
réaliser, c’est un outil de communication, il est élaboré en collaboration avec un client ou un
encadreur pour être validé, il sert de référence aux participants du projet, permet d’organiser,
de lister, de cadrer l’ensemble d’un projet avec précision, il doit être compréhensible. Dans ce
chapitre, il sera question de donner le contexte général de notre mini projet qui s’intitule
« conception et réalisation du jeu MOTUS », d’évoquer sa problématique ainsi qu’une
présentation incluant le principe et les règles du jeu.
1-CONTEXTE GENERAL DU MINI-PROJET
Ce projet s’inscrit dans le cadre académique du programme de la troisième année de l’Ecole
Supérieure Privée de l’Ingénierie et de Technologie (ESPRIT). Ceci dans le but d’appliquer
les connaissances acquises en langage C plus précisément dans les modules algorithmique &
programmation C et Structures de données dans un projet réel. Le sujet qui nous a le plus
attiré est la réalisation du jeu « MOTUS ».
2-PROBLEMATIQUE
Comme tout jeu, Motus doit garder un aspect ludique tout en préservant toute sa complexité.
Mais en plus de cela, il doit être un outil linguistique valide qui permet d’accroitre le
vocabulaire du joueur. C’est un outil qui peut offrir des opportunités d’animation
intéressantes, le recours à la réflexion permet de dépasser des difficultés importantes de
langues. La distraction est devenue en plus de l’éducation ou de l’instruction une priorité dans
la vie de l’homme et l’idéal serait de concilier les deux, ce qui est le but de notre jeu.
Cependant, il existe plusieurs autres jeux de mots tels que les mots croisés, les mots fléchés,
le scrabble mais nous avons choisis Motus.
CHAPITRE 1 : CAHIER DE CHARGE

3-PRESENTATION DU PROJET
Notre projet va mettre en évidence le jeu Motus qui serait d’origine néerlandaise et aurait été
créée en 1989 ,c‘est un jeu de recherche de mot pour une bonne connaissance de la langue
française, il suit le principe suivant : Tout d’abord il est présenté sous forme de grille à
carreaux, où chaque carreau contient une lettre du mot donné et chaque ligne le mot entré par
le joueur ; il consiste à chercher un mot d’une taille bien définie en fonction du nombre
d’essais fixé, la première lettre du mot est donné par le système ainsi qu’une autre lettre
faisant partie de celui-ci, plus nous avançons dans les essais plus les lettres faisant partie du
mot entré par le joueur sont précisées si celles-ci appartiennent au mot à rechercher et restent
fixées si celles-ci sont entrées à la bonne position. A la fin du nombre d’essais fixé par le
système, si le mot n’a pas été trouvé, on passe à un autre mot, tout en donnant le mot qui n’a
pas été trouvé précédemment, si le mot est trouvé, le score est incrémenté.
Le jeu va suivre les règles suivantes :
- Le joueur doit choisir un nombre d’essais prédéfini par le système.
- Le joueur doit choisir un nombre de lettres prédéfini par le système.
- Si le nombre de lettres entrées par le joueur est supérieur au maximum de lettres
demandées par le système, la dernière lettre du mot sera modifiée ; si par contre le
nombre de lettres est inférieur, le mot entré par le joueur n’est pas pris en compte.
- Si le joueur parvient à trouver le mot juste avant le nombre d’essais maximal il
gagne dix points et passe à un autre mot.
- Après 90 parties le jeu est terminé.
Conclusion
Tout au long de ce chapitre, nous avons présenté le cahier de charge de notre projet de son
contexte général vers la présentation dudit projet en passant par sa problématique. Le chapitre
suivant fera l’objet d’une analyse et d’une conception de notre application.

Introduction
Ce deuxième chapitre va nous permettre d’élaborer les différentes démarches consistant à
rechercher et à caractériser les fonctions offertes par l’application pour satisfaire les besoins
de ses utilisateurs. Il sera question ici d’identifier les acteurs avec les besoins fonctionnels et
non-fonctionnels ainsi que de ressortir une conception générale et détaillée.
1- ANALYSE
a-Identification des acteurs
Les acteurs ici sont le joueur et l’administrateur.
b-Besoins fonctionnels
Les fonctionnalités basiques de notre application doivent être les suivantes :
- Choix aléatoire d'un mot dans le dictionnaire et affichage d’une ou plusieurs
lettres au hasard de celui-ci. Pour nous deux.
- Récupération de la proposition du joueur.
- Si le nombre de lettres du mot saisi par le joueur est inférieur au maximum
autorisé, le mot entré par le joueur n’est pas pris en compte.
- Vérification du mot récupéré.
- Au cas où celui-ci n'est pas celui attendu, et le nombre d'essais inférieur au
maximum autorisé, indiquer si elles existent les lettres qui sont présentes dans
le mot attendu mais mal placées ainsi que celles qui sont bien placées.
- Si le mot est celui attendu ou si le nombre d'essai maximal est atteint,
initialiser un autre mot.
- Afficher un message de succès ou d'échec
- Mettre une politique d’attribution des scores.
c-Besoins non fonctionnels
Ce sont les besoins obligatoires mais qui ne sont pas dans le but de l’application. Nous avons après
chaque essai du mot la couleur rouge pour signifier que la lettre du mot cherché est à sa position
CHAPITRE 2 ANALYSE ET CONCEPTION

normale, la couleur verte pour indiquer que celle-ci appartient au mot cherché mais n’est pas à la
bonne position et la couleur blanche montrer que la lettre du mot initialiser par le système
n’appartient pas à celui-ci.
d- Besoins optionnels
Ce sont des besoins qui ne sont pas obligatoires, qui ne sont pas nécessaire au fonctionnement
de l’application. Dans notre cas nous avons :
- Choix du nombre de lettres par le joueur
- Choix du nombre d'essai par le joueur
- Enregistrer les dix meilleurs scores ainsi que les parties non terminées.
- Possibilité d’obtenir des synonymes du mot en question.
Après avoir défini les différentes fonctions de notre mini-projet, nous allons les modéliser
suivant un schéma de conception.
2-CONCEPTION
a- Conception générale
Il s’agit ici du schéma fonctionnel de notre application contenant les fonctions génériques de
l’application. Chaque fonction pouvant bien évidement nécessiter une sous fonction pour une
bonne manipulation.

Figure 1 : diagramme hiérarchique
Interface : cette fonction est chargée de la fabrication de l’interface du jeu.
Initialiser: Cette fonction doit choisir de façon aléatoire un mot dans le dictionnaire et
afficher au hasard une ou deux lettres de ce mot.
Saisir : Cette fonction a pour rôle de recevoir la proposition de mot du joueur. Si le mot saisi
a une taille supérieure à la taille du mot fixée au départ, la dernière lettre du mot changera tant
que le joueur continuera à saisir et les autres lettres resteront identiques.
Vérifier : Elle teste si le mot saisi est celui recherché.
Si c'est le cas :
 Elle affiche un message de succès puis initialise un nouveau mot.
 Sinon, elle affiche un message d’échec,
puis rechercher_lettres du mot saisi qui figurent dans le mot attendu et les indiquer. S'il
en existe, indiquer celles qui sont à la bonne position et celles qui ne le sont pas tel que dans
le mot recherché. En suite, incrémenter le nombre d'essais. Si celui-ci est supérieur au
nombre maximal d'essais autorisé, message: fin de la partie, affichage du résultat et initialiser
un autre mot.
Quitter : Enfin donner la possibilité au joueur d'annuler la partie.
b-Conception détaillée
Il s’agit des fonctions spécifiques de notre application définies sous forme d’organigramme.

Titre : Organigramme de conception détaillée
(1)Au début du jeu nous avons la page de bienvenue dans laquelle nous retrouvons le nom de
l’application développée ainsi que ses auteurs. (2)La fenêtre suivante permet de se connecter
soit en tant que administrateur, soit en tant que joueur ; le root après authentification a la
possibilité de modifier le dictionnaire en ajoutant et/ou en supprimant un nouveau mot ; le
joueur quant à lui devra d’abord s’authentifier avant de choisir les différentes options du jeu à
savoir le nombre de lettres ainsi que le nombre d’essais. Après avoir fait son choix celui-ci
peut commencer la partie en cliquant sur l’option jouer. (3)Le système enregistre les choix du
joueur et affiche l’interface du jeu sur la fenêtre qui suit ensuite (4) initialise le mot à
rechercher en affichant la première lettre du mot ainsi qu’une autre lettre faisant partie du mot
choisie aléatoirement, le joueur saisit le mot ;le système vérifie si chaque lettre du mot saisi
correspond au mot recherché ; si le mot trouvé est le même que le mot recherché, le système
incrémente le score du joueur puis initialise un nouveau mot, sinon (5) à chaque essaie si le
mot n’est pas trouvé, le système affiche un message d’échec. Dans le cas contraire(6) le
1 2 3 4 5 6
7 7
Bienven
uueMes
sageme
ssage
Entrée dans le programme :
mainRechercher_
lettresRechercher_caractère
initialiser
echec
messag
eInitiali
seriniti
aliser
Rechercher_l
Quitterquitte
r
Indiquer_lett
r
Nombre
d’essai
maximal ?
enregistrerifs
yn
synony
meroot joueur
entrer
cadre
?
Enter_dico
Modifier_dico
option
S’authentifi
er
Nb essai nb_lettr
e
affich
er
incrémenter
lettre
jeu
Init_mo
t
Init_sai
si
saisir
vérifier
Rechercherlettr
e
Indiquer_lettre
Mot
trouvé
?

système donne la possibilité au joueur d’entrer le synonyme du mot trouvé ainsi que (7)
d’enregistrer la partie.
Conclusion
L’analyse et la conception faites dans ce chapitre vont nous permettre de mettre en place
notre fameux jeu MOTUS. Sa réalisation consiste finalement au choix de la plateforme
utilisée et de l’implémentation des fonctions précédentes pour fournir les fonctionnalités que
nous avons présentées dans les spécifications.
Introduction
Dans ce chapitre, il s’agit de la réalisation proprement dite de l’application et de la
présentation de l’environnement de travail ainsi que son fonctionnement. NB : Notre
application tourne autour de la manipulation des fichiers et des tableaux. Notre choix a été
porté sur ces outils car ils nous ont parut être les plus adaptés en restant dans le cadre de
l’objet du projet qui est le module « mini projet programmation C ».
1-ENVIRONNEMENT MATERIEL ET LOGICIEL
Configuration matérielle : notre application a été réalisée sur un ordinateur de type HP 620.
Comportant une mémoire RAM de 4Go, un processeur Pentium(R) Dual-Core CPU T4500
2*2.30GHz.
CHAPITRE 3 REALISATION DU JEU MOTUS

Configuration logicielle : nous avons utilisé le logiciel Borland C++, tournant sur Windows 7
Edition Familiale Premium.
2-TEST ET VALIDATION
Figure 2 : fenêtre de bienvenue
La confidentialité des données étant devenue un objectif majeur dans tout système accessible
par plusieurs personnes, nous avons pensé à une identification pour tout accès à notre
application. Nous proposons deux interfaces : joueur et Admin
.

Figure 3 Authentification du joueur
L’administrateur a la possibilité après authentification de faire des modifications par
exemple en ajoutant un mot dans le dictionnaire après avoir choisit la taille du mot à insérer.
Le joueur quant à lui après son authentification doit choisir la taille du mot ainsi que le
nombre d’essais avant de lancer le jeu proprement dit (pour pouvoir jouer), il peut aussi
consulter les règles du jeu, les meilleurs scores (ou alors quitter).
Figure 4 Options du joueur

Figure 5 : choix du nombre d’essais
Figure 6 choix du nombre de lettres

Figure 7 Grille de scores
Le joueur peut entrer directement dans la page du jeu en choisissant l’onglet « jouer ». Toute
fois, si, il ne choisit aucune option et passe directement au jeu, des valeurs par défaut seront
attribuées.
Figure 8 Fenêtre principale du jeu
Ci- dessus, nous avons l’affichage principal de notre jeu (le joueur « éric »n’a pas encore
commencé à jouer.

Figure 9 Fenêtre du jeu 1
Ci-contre le joueur « éric » a joué mais au bout 7 essais il n’a pas pu trouver le mot
initialement recherché (à chercher), le système lui donne la réponse à la fin des essais et il a
la possibilité de continuer (C), de quitter (Q) ou d’afficher les synonymes de celui-ci (S).

Dans la fenêtre ci-dessous le joueur est à sa quatrième partie, il a trouvé le mot juste au bout
de trois essais, le score passe à 40.
De même, dans le but d’accroitre la rentabilité de notre jeu d’un point de vue instructif, nous
avons ajouté une option permettant d’avoir des synonymes de chaque mot.
Ci-dessus, affichage des synonymes après avoir fait un Ctrl-S.

Le joueur quitte la partie.
Conclusion
Après avoir détaillé l’environnement matériel et logicielle de notre application et présenter
son fonctionnement à l’aide de captures d’écran, nous pouvons dire que l’ensemble des
fonctions réalisées pour la mise en place de cette application ont une exécution séquentielle
c'est-à-dire que une fonction s’exécute à la fois. Pour attribuer un temps à chaque essai, nous
avons constaté la nécessité d’exécution de deux bouts de codes à la fois : un code de
chronomètre et le reste du jeu. Ce que nous n’avons pas pu faire mais comptons néanmoins le
faire pour compléter notre application. La réalisation de cette application s’est étendue sur 7
semaines organisées d’une manière progressive.

BIBLIOGRAPHIE
http://files.codes-sources.com/fichier.aspx?id=29972&f=Source%5CMotus.cpp
http://www.gladir.com/CODER/C/toupper.htm
http://www.cplusplus.com/reference/clibrary/cctype/isalpha/
http://www.cplusplus.com/reference/clibrary/cstdio/fflush/
http://www.programmingsimplified.com/c/conio.h/wherex
http://www.cplusplus.com/reference/clibrary/cstdio/fgets/
http://www.liafa.jussieu.fr/~yunes/cours/systemes/stdlib.html

CONCLUSION GENERALE
Le développement et la mise sur pieds de l’application jeu MOTUS a été un projet
d’envergure qui s’est tenu sur sept semaines. Ce développement n’a pas été aussi aisé mais
nous pouvons être fiers du résultat car nous avons atteint la grande partie de nos objectifs.
Nous avons rencontré bien de problèmes au cours du développement dont certains restent non
résolus tel que le chronométrage en parallèle de la partie, l’enregistrement et entre autre le
mode graphique que nous avons bien voulu implémenté. Et bien évidement nous comptons
faire tout cela. Mais d’ici la, nous croyons que notre application telle quelle constitue un outil
à la fois linguistique et assez distrayant. Ce projet nous a permis de mieux maitriser les outils
appris dans le cours de programmation C et surtout de voir comment les utiliser dans le cadre
d’un projet concret.

Jeu Motus C

Contenu connexe

Tendances (20)

En vedette (20)

Similaire à Jeu Motus C (20)

Dernier (20)

Jeu Motus C