Projet1 mastermind 2010-2011

ALARGENT Sébastien
LP GEII AII
Option SARI
Rapport de Projet :

M1-5 Informatique :
Programmation en langage C
Mastermind

Projet d’études effectué à l’Iut de Nice, au sein du département GEII,
sous la tutelle de Gilles MENEZ et de Jean-Louis SALVAT.

M3-10 Informatique :
Projet Mastermind

1

Sommaire :

Introduction

p3

Présentation de la formation

p4

Cahier des charges

p5

Présentation du logiciel Visual Studio 2010

p6

Le Mastermind

p8

Le programme

p9

Mon programme en Console

p 19

Conclusion

p 22

Projet Mastermind

2

Introduction :
Le déroulement de mon projet c’est effectué au sein de l’Institut Universitaire Technologique de
Nice, plus précisément dans le département Génie Electrique Informatique Industriel.
Tout au long de ce projet, j'ai travaillé dans le but de créer le jeu du Mastermind en langage c.
Le Mastermind est un jeu de société, de réflexion, et de déduction, inventé par Mordecai Meirowitz dans les
années 1960.
Nous mettrons, dans un dernier temps, nos compétences en pratique en présentant ce projet à l’oral.

Projet Mastermind

3

Présentation de la formation
La Licence professionnelle AII (Automatique et Informatique Industrielle) est hébergée par le département
GEII de l'IUT de Nice Cote d'Azur.
L'objectif de la licence est de former des automaticiens possédant de solides compétences en informatique
embarquée. La licence professionnelle AII (option Systèmes Automatisés et Réseaux Industriels) a pour
objectif principal l'insertion directe de nos étudiants dans le monde du travail et c'est pour cette raison que
nous privilégions le contrat de professionnalisation.

Les métiers associés
Le métier d’automaticien a fortement évolué depuis quelques années avec l’arrivée des nouvelles IHM
(Interfaces Homme Machine), de nouveaux réseaux de communications (TCP/IP, CANOpen, Profinet,…),
et de nouveaux outils de télégestion et de supervision. L’automaticien est devenu intégrateur de solutions.
Les nouvelles technologies grand public (PDA, Tablet PC), les réseaux de communications sans fils et de
localisation associés aux outils de programmation pour l’embarqué ouvrent de nouvelles perspectives pour
des techniciens de niveau bac+3 motivés par l’informatique industrielle.

Le module Informatique
Nous devons être capable de créer un projet en mode console sous Visual C++, capable de compiler et
débugger un programme écrit en C.
On doit connaitre les types de variables et les fonctions de lecture et écriture de la bibliothèque stdio.h.
On doit être capable d’écrire et tester un programme simple en fonction d’un cahier des charges, capable de
faire une découpe en fonctions réparties dans plusieurs fichiers et être capable de programmer en utilisant les
tableaux, les pointeurs et structures de données.

Projet Mastermind

4

Cahier des charges
Énoncé général du besoin :
Créer un programme en langage C permettant la gestion du fonctionnement d’un mini-jeu.

Objectif du projet :
Mettre en place le jeu pour qu’on puisse s’en servir correctement et y jouer.

Description du projet :
Le Mastermind va être créer sur les mêmes bases. C'est-à-dire le but est de jouer contre l'ordinateur. En
début de partie, celui-ci va choisir une combinaison de 4 chiffres compris entre 0 et 9 aléatoirement. Le
joueur devra trouver cette combinaison en 5 Coups.
On lui indiquera au fil de la partie quel chiffres est à la bonne place, quel chiffre est à la mauvaise place et si
dans les chiffres proposées lesquels sont dans la combinaison.
Au début du programme, on indiquera à l'utilisateur une aide pour qu'il comprenne comment jouer au
Mastermind.

Projet Mastermind

5

Présentation du logiciel Visual Studio 2010

Microsoft Visual Studio est une suite de logiciels de développement pour Windows conçu par Microsoft. La
dernière version s'appelle Visual Studio 2010.
Visual Studio est un ensemble complet d'outils de développement permettant de générer des applications
Web ASP.NET, des Services Web XML, des applications bureautiques et des applications mobiles. Visual
Basic, Visual C++, Visual C# et Visual J# utilisent tous le même environnement de développement intégré
(IDE, Integrated Development Environment), qui leur permet de partager des outils et facilite la création de
solutions faisant appel à plusieurs langages. Par ailleurs, ces langages permettent de mieux tirer parti des
fonctionnalités du Framework .NET, qui fournit un accès à des technologies clés simplifiant le
développement d'applications Web ASP et de Services Web XML grâce à Visual Web Developer.

Visual Studio 97
La première version de Visual Studio a été publiée en 1997 par Microsoft, afin de rassembler au sein d'un
même environnement de développement plusieurs de ses outils de programmation.
Visual Studio 97 incluait Visual Basic 5.0 et Visual C++ 5.0, pour le développement d'application Windows,
Visual J++ 1.1 pour la programmation Java et Visual FoxPro 5.0 pour la programmation xBase. Visual
InterDev était utilisé pour créer des pages web générées dynamiquement en ASP.

Visual Studio 2008
Cette version (nom de code Orcas) est sortie en version finale à la fin de l'année 2007. Parmi les nouveautés
de cette version : elle est fondée sur le .NET Framework 3.5 des outils de métrologie relatifs au code
(indicateurs du nombre de lignes, profondeur des routines, calcul de la complexité cyclomatique), relatifs à
la performance (mémoire utilisée, temps d'exécution) gestion complète du développement collaboratif et des
versions (auteurs et révisions du code) en intégrant l'outil PowerTools, possibilité d'automatiser les
processus de compilation et intégration (avec des triggers), meilleure gestion des tests avec possibilité
d'élaborer des scénarios de test, module de test spécifique aux applications, Ajax suppression des wizards
assistant et de la bibliothèque ATL pour faire des services web en C++ amélioration de prise en charge des
fichiers XML (validation IE...).
Le numéro de version interne de Visual Studio 2008 est 9.0.

Projet Mastermind

6

Visual Studio 2010
Cette version est sortie en version finale le 12 avril 2010. Cette nouvelle version utilise la version 4.0 du
.NET Framework dans le logiciel ainsi qu'une refonte de l'interface graphique propulsé par WPF.
Un nouveau langage de programmation fait officiellement son apparition : F#
A cette occasion, le logo a changé, pour une version plus 'moderne'. Les différentes déclinaisons de Visual
Studio ont elles aussi changé de nom par soucis de clarification de l'offre.

Microsoft Visual Studio Express
Microsoft Visual Studio Express est une version "allégée" disponible gratuitement à des buts éducatifs.
Elle reprend, en limitant les fonctionnalités les plus avancées, l'interface de Visual Studio, et en limitant
l'usage à un seul langage de programmation par installation.
Une version "CTP" de Microsoft Visual Studio 2010 Express est sortie le 14/03/2010 pour développer les
applications pour Windows Mobile 7 incluant une première version 4.0 du framework .NET.
Exemple : Page d’ouverture de visual studio lorsqu’une solution s’ouvre :

Sur la gauche, nous avons une arborescence de notre solution.
En haut, la barre d’outils avec tous les boutons qui nous serviront à sauvegarder, compiler dégoguer.
Au centre, la page qui nous laisse place au code.

Projet Mastermind

7

Le Mastermind
Introduction :
Le Mastermind est un jeu de société, de réflexion, et de déduction, inventé par Mordecai Meirowitz dans les
années 1960.
Il se présente généralement sous la forme d'un plateau perforé de 10 rangées de quatre trous pouvant
accueillir des pions de couleurs.
Le nombre de pions de couleurs différentes est de 8 et les huit couleurs sont généralement : rouge ; jaune ;
vert ; bleu ; orange ; blanc ; violet ; fuchsia.
Il y a également des pions blancs et rouges (ou noirs) utilisés pour donner des indications à chaque étape du
jeu.
Un joueur commence par placer son choix de pions sans qu'ils soient vus de l'autre joueur à l'arrière d'un
cache qui les masquera à la vue de celui-ci jusqu'à la fin de la manche.
Le joueur qui n'a pas sélectionné les pions doit trouver quels sont les quatre pions, c'est-à-dire leurs couleurs
et positions.
Pour cela, à chaque tour, le joueur doit se servir de pions pour remplir une rangée selon son idée qu'il se fait
des pions dissimulés.
Une fois les pions placés, l'autre joueur indique :
1. le nombre de pions de la bonne couleur bien placés en utilisant le même nombre de pions rouges ;
2. le nombre de pions de la bonne couleur, mais mal placés, avec les pions blancs.
Il arrive donc surtout en début de partie qu'il ne fasse rien concrètement et qu'il n'ait à dire qu'aucun pion ne
correspond, en couleur ou en couleur et position.
La tactique du joueur actif consiste à sélectionner en fonction des coups précédents, couleurs et positions, de
manière à obtenir le maximum d'informations de la réponse du partenaire puisque le nombre de propositions
est limité par le nombre de rangées de trous du jeu. Dans la plupart des cas, il s'efforce de se rapprocher le
plus possible de la solution, compte-tenu des réponses précédentes, mais il peut aussi former une
combinaison dans le seul but de vérifier une partie des conclusions des coups précédents et de faire en
conséquence la proposition la plus propice à la déduction d'une nouvelle information.
Le joueur gagne cette manche s'il donne la bonne combinaison de pions sur la dernière rangée ou avant.
Dans tous les cas, c'est à son tour de choisir les pions à découvrir.

Projet Mastermind

8

Le programme

Le projet du Mastermind a été crée sous Visual studio 2010.
Le programme se décompose en 8 sous programmes, il y a 3 fichiers et un programme principal sous plus de
220 lignes de code :
- Le main va gérer toutes les autres fonctions
- L'initialisation va tirer les nombres aléatoires à chaque début de partie
- La réinitialisation va remettre à 0 plusieurs paramètres
- La fonction « démarrer une partie » va commencer la partie qui va gérer l'affichage principale, la
saisie des numéros, le test des numéros et l'affichage
- L'affichage départ va afficher sur la première page l'aide et le début du programme
- La fonction saisie des numéros va afficher nos propositions de combinaisons
- La fonction test des numéros va comme son nom l'indique tester tous les numéros qu'on rentre pour
savoir s'ils sont a la bonne ou mauvaise place
- La fonction d'affichage va afficher si les numéros sont a la bonne ou mauvaise place
- Et la fonction demande de rejouer si on veut faire une nouvelle partie

Projet Mastermind

9

Les différentes structures qu’on va utiliser dans le programme :
Structures conditionnelles :
If …. Else
Cette structure permet l'exécution d'une séquence au choix parmi 2. Le choix de la séquence dépend de la
valeur d'une variable dite condition.
Do … While (répéter tant que)
Cette structure permet de répéter plusieurs fois l'exécution d'une séquence. En premier lieu la séquence est
exécutée. Une fois terminée le processeur évalue la condition si cette condition est vraie alors la séquence
est a nouveau exécutée mais si cette condition est fausse le processeur continue l'exécution du programme à
la ligne qui sont écrites en dessous.
For …
Cette troisième et dernière structure offre une syntaxe assez riche pour condenser en une ligne les
instructions qu'il aurait fallu écrire sur plusieurs lignes.
Syntaxe : For (expression1;expression2;expresion3) {séquence}
Srand..Rand :
La fonction Srand qui permet d'initialiser le système aléatoire et Rand permet d'obtenir un nombre entre 0
et rand max très grand
Tableaux : nb propose, nb valide, nb choisi :
Un tableau est un ensemble de cases mémoire destinées à contenir une valeur d'un même type.
Ces tableaux possèdent un nombre d’éléments définis en début du programme.
Printf, puts permet d'afficher à l'écran un ensemble de chaines de caractères.
Puts permet un affichage avec retour à la ligne
Lorsque l'on fait l'acquisition d'un caractère c'est l'opération getch qui va interpréter mes numéros qui sont
définies dans conio.h, getch n'a pas besoin d'attendre la validation.

Projet Mastermind

10

Organisation du programme :
Nous allons maintenant découper ce programme en plusieurs fichiers.
Tout programme doit en effet être découpé en différents fichiers ce qui permet la réutilisation des fonctions
dans de nouveaux projets.
Toutes les déclarations de fonctions doivent être mises dans un fichier .h
Mastermind.h sert pour la définition des constantes et prototypes de sous programmes.
Le code des fonctions est placé dans le fichier Mastermind.c
Le compilateur doit compiler le fichier main.c et le fichier de bibliothèque mastermind.c.

Les 3 fonctions et le code :
Le main.c :
#include "Mastermind.h"
#include <stdio.h>
#include <stdlib.h>

/* L'instruction include indique les bibliothèques à charger */
/* Stdio.h permet entre autre l'usage de printf qui affiche une chaine de caractère */

int main()
{
int rejouer;
initialisation();

/* Point d'entrée de tout programme main */

do
{

/* Déclaration de l'entier rejouer */
/* Appel et exécution de la fonction initialisation */
/* Faire les 3 fonctions */

reinitialisation();
demarrer_une_partie();
rejouer = demande_rejouer();
}
while(rejouer == OUI); /* Tant que l'on veut rejouer */
}

Le compilateur va compiler ce fichier et le fichier de bibliothèque Mastermind.c.
Cette partie de programme va exécuter les fonctions qui sont situés dans le fichier Mastermind.c.
En effet, au tout début de mon programme, il va y avoir une initialisation qui va remettre à 0 mes nombres
aléatoires ce qui évitera d’avoir tout le temps la même série.
Ensuite, on va répéter le programme tant qu’on voudra rejouer une partie.
Dans ma boucle qui va répéter la séquence, nous allons avoir une deuxième initialisation qui va mettre les
paramètres où on choisit les nombre, le nombre de proposition et si la combinaison a été trouvé, à zéro.
Une fois la deuxième initialisation faite, le programme pourra commencer.
Le programme se fermera lorsqu’on ne voudra plus jouer.

Projet Mastermind

11

Le Mastermind.c :
#include "Mastermind.h"
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <conio.h>
#define MAX 10

/* L'instruction include indique les bibliothèques à charger */
/* Stdio.h permet entre autre l'usage de printf qui affiche une chaine de caractère */

/* pour l'instruction getch */
/* Bornes des nombres aléatoires compris entre 0 et 9 inclus */

Cette partie du programme met à jour les nombres aléatoires.
void initialisation (void)
{
srand(time(0));
}

/* Fonction d'initialisation qui va tirer les nombres aléatoires */
/* Le mot clé void indique que initialisation() est une procédure est pas une fonction */
/* Tirage des nombres aléatoires */

La fonction réinitialisation va mettre plusieurs paramètres à 0 et choisir les nombres aléatoires :
- Choix des 4 nombres de ma série choisi aléatoirement entre 0 et 9
- Le nombre de proposition qu’on a fait, est mis à 0 car on n’a pas commencé à jouer
- Initialisation de la combinaison car elle n’a pas encore été trouvé
- Initialisation du nombre de coups qu’on va faire
void reinitialisation (void)
{
int i;

/* Fonction de réinitialisation */ /* Elle ne renverra pas de valeur de retour */
/* Déclaration de l'entier i */

for (i=0;i<4;i++)
/* Boucle for des 4 nombres */
{
nb_choisi[i] = rand() % MAX;
/* Les 4 nombres vont être choisi aléatoirement entre 0 et 9 */
nb_proposition = 0;
/* Initialisation du nombre de proposition, il ya 0 dans la case nb_proposition */
combi_trouve = 0;
/* Initialisation de la combinaison qui a été trouve, il y a 0 dans la case combi_trouve*/
nb_coup = 0;
/* Initialisation de l'affichage du nombre de coup */
}
}

La fonction Démarrer :
Une partie va lancer plusieurs fonctions :
- La partie d’affichage de l’aide lors de l’exécution du programme
- Une boucle qui va lancer la saisie des numéros, qui va tester si mes numéros sont à la bonne place et
leur affichage
Des que la combinaison est trouvé ou que le nombre maximum de proposition qu’on a fait est atteint, on sort
de la boucle.
void demarrer_une_partie (void)
/* Fonction de demarrage de la partie */
{
affichage_depart();
/* Execution de la fonction affichage_depart */
do
/* Faire Répète plusieurs fois */
{
saisie_des_numeros();
/* l'éxécution de la fonction saisie_des_numeros */
test_des_numeros();
/* l'éxécution de la fonction test_des_numeros */
affichage();
/* l'éxécution de la fonction affichage */
}
while(combi_trouve != TROUVE && nb_proposition < NB_PROPOSITION_MAX); /* Tant que combinaison n'est pas trouvé
et que le nombre de proposition est en dessous du maximum */
}

Projet Mastermind

12

La fonction Affichage départ :
Elle va afficher l’entête du programme, une petite aide pour expliquer comment le programme fonctionne.
void affichage_depart (void) /* Fonction d'affichage de la 1ere page */
{
system ("CLS");
/* Il permet d'effacer la console à chaque boucle */
puts("==========================================================================="); /* Affichage
*/
puts("===========================================================================");
puts("============================ Jeu du MASTERMIND ============================");
puts("===========================================================================");
puts("===========================================================================");
puts("");
puts("Une serie de 4 numeros est tire au hasard.");
puts("Le but est de retrouver la serie en 5 coups.");
puts("");
puts("Si un numero que vous avez propose est correct, nun O apparaitra en dessous de ce numero.");
puts("");
puts("Si un numero que vous avez propose est parmi les quatres tires nmais pas a la bonne place, un N apparaitra en dessous.");
puts("");
puts("Le rappel des numeros que vous avez tappe s'affichera a gauche de l'ecran.");
puts("");
puts(" --------------------------------------------------------------------------");
printf ("Trouver les 4 bons numeros : X X X Xt Coup Numero 1ntttt"); /* Affichage des 4 nombres aléatoires masqués et
du numéro de coup a ufur et à mesure*/
nb_coup++; /* Incrementation du nombre de coup nb_coup =1 */
}

En console :

Projet Mastermind

13

La partie Saisie des numéros :
-

le but du Mastermind est de trouver le plus rapidement la série de 4 chiffres qui est caché.
On rentre nos 4 chiffres compris entre 0 et 9
Si nos numéros sont bien compris entre 0 et 9 alors il s’affiche dans la console
J’incrémente à la fin mon nombre de coup

void saisie_des_numeros (void) /* Fonction de la saisie des numeros */
{
int i; /* Déclaration de l'entier i */

/* Début de la séquence */

for (i=0;i<4;i++) /* Boucle for des 4 nombres */
{
do /* Faire la proposition des nombres */
{
nb_propose[i] = getch(); /* Definies dans conio.h */ /* getchar me collait les 4 nombres et ne prenait pas en compte les espaces */
}
/* Sans attente de validation */
while(nb_propose[i] < '0' || nb_propose[i] > '9'); /* Tant que les nombres sont inférieur à 0 et supérieur à 9 */
nb_propose[i]&=0x0F; /* Pour pouvoir ecrire en lettre affichée sinon j'affiche en ASCII */
printf("%d ",nb_propose[i]); /* Affichage les lettres que je rentre petit à petit comprenant l'espace */
}
nb_proposition++;
}

/* Incremente le nombre de coup */
/* Fin de la séquence */

La partie Test des numéros :
Cette fonction est l’une des fonctions les plus importantes du programme.
C’est celle qui va indiqué si les chiffres que je viens de rentrer, correspondent à ma série de 4 chiffres
cachée.
En effet, Si le nombre que j’ai proposé est pareil que le nombre caché et à la bonne place alors on indiquera
dans une autre fonction que celui-ci est à la bonne place.
Si le nombre que j’ai choisi ne correspond pas au nombre proposé alors celui-ci n’est pas bon. Mais si celui
que j’ai proposé est à la mauvaise place alors j’indique que celui-ci n’est pas à la bonne place.
J’utilise une boucle for pour répéter la procédure pour les 4 chiffres.
void test_des_numeros (void) /* Fonction de test des numéros si ces numéros sont vrai ou faux */
{
int i; /* Déclaration de l'entier i pour la boucle for */
for (i=0;i<4;i++) /* Boucle des 4 nombres */
{
if (nb_propose[i] == nb_choisi[i]) /* Si le nombre qu'on propose à la bonne place est égale au nombre choisi aléatoirement à la
bonne place */
{
nb_valide[i] = Bonne_place; /* Alors le nombre est à la bonne place */
}
else
/* Si le nombre qu'on propose n'est pas égale au nombre choisi à la bonne place */
{
nb_valide[i] = Nombre_faux; /* Alors le nombre n'est pas le bon */
if (i == 0) /* A la position numero 1 */
{
if (nb_propose[i] == nb_choisi[1] || nb_propose[i] == nb_choisi[2] || nb_propose[i] == nb_choisi[3]) /* Si le numero
qu'on rentre à la position 1 est égale au numéro aleatoire au position 2 3 et 4 alors */
nb_valide[i] = Mauvaise_place; /* Le nombre est à la mauvaise place */

Projet Mastermind

14

}
if (i == 1)
{

/* A la position numero 2 */

}
if (i == 2)
{
}
if (i == 3)
{
nb_valide[i] = Mauvaise_place;
/* Le nombre est à la mauvaise place */
}
}
}
if (nb_valide[0] == Bonne_place && nb_valide[1] == Bonne_place && nb_valide[2] == Bonne_place && nb_valide[3] ==
Bonne_place)
combi_trouve = TROUVE; /* Si mes 4 nombres proposés sont validés alors la combinaison est trouvé */
}

La partie Affichage :
Cette fonction est la deuxième fonction la plus importante du programme. Elle est en coordination avec la
fonction Test des numéros.
En effet, si le chiffre que j’ai rentré est à la bonne place alors je vais afficher un O. Si le chiffre que je rentre
est dans ma série de 4 chiffres aléatoires mais n’est pas à la bonne place, je le signale avec un N.
Si le numéro que je rentre n’est pas du tout dans la série de 4 chiffres, je ne donne aucune indication.
void affichage (void) /* Fonction d'affichage de validation des numeros */
{
int i; /* Déclaration de l'entier i pour la boucle for */
printf ("ntttt");
dessous */

/* Affichage du saut de ligne et des tabulations pour pouvoir afficher si mes nb proposés sont bons juste en

for (i=0;i<4;i++) /* Boucle des 4 nombres */
{
if (nb_valide[i] == Bonne_place) /* Si mon nombre proposé est à la bonne place alors */
{
printf ("O "); /* J'affiche un O pour dire qu'il est à la bonne place */
}
if (nb_valide[i] == Nombre_faux) /* Si mon nombre proposé n'existe pas dans la combinaison alors */
{
printf (" "); /* J'affiche rien */
}
if (nb_valide[i] == Mauvaise_place) /* Si mon nombre proposé est à la mauvaise place alors */
{
printf ("N "); /* J'affiche un N */
}
}

Projet Mastermind

15

Ensuite, dans l’autre partie de la fonction, si la combinaison est trouvée en un certain nombre de coups alors
je vais afficher un commentaire marrant.
if (combi_trouve == TROUVE) /* Si la combinaison de mes 4 chiffres proposés est bonne alors */
{
if (nb_coup == 1) /* Si je trouve la combinaison du 1er coup alors j'affiche ..*/
{
printf("nnLA CHANCE !!!!n Vous etes cocu, allez jouer à l'EURO Millions!nVous avez trouve la
combinaison du 1er coup.");
}
if (nb_coup == 2) /* Si je trouve la combinaison en 2 coups alors j'affiche ..*/
{
printf("nnChance, Appelez votre compagne !!!nVous avez trouve la combinaison en 2 coups.");
}
{
printf("nnExcellent !!nTres bonne analyse.nVous avez trouve la combinaison en 3 coups.");
}
{
printf("nnBien joue.nVous avez trouve la combinaison en 4 coups.");
}
if (nb_coup > 4) /* Si je trouve la combinaison en 5 coups alors j'affiche ..*/
{
printf("nnEnfin :)nVous avez trouve la combinaison en 5 coups.");
}
}

Si la combinaison n’est pas trouvée au bout de 5 coups alors j’aurai un autre commentaire qui apparaitra.
else /* Si la combinaison de mes chiffres n'est pas encore trouvé alors */
{
if (nb_proposition == NB_PROPOSITION_MAX) /* Si je ne trouve pas la bonne combinaison j'affiche */
{
printf ("nDommage.nVous etes trop nul.nVous n'avez pas trouve la combinaison.nVous avez le Qi d'une moule.nVotre Qi est
egale a 2.nLa bonne combinaison etait : %d %d %d %d",nb_choisi[0],nb_choisi[1],nb_choisi[2],nb_choisi[3]);
}

Projet Mastermind

16

Enfin, à la fin de ma fonction, j’incrémente le nombre de coups que je viens d’effectuer.
else /* Je continue à chercher la bonne combinaison */
{
if (nb_coup < 4) /* Si mon nombre de coups est inférieur à 4, je cache les 4 numéros et j'affiche le numéro
du coup */
{
nb_coup++; /* J'incremente nb_coup */
printf ("nnttttX X X Xt Coup Numero %dntttt", nb_coup); /* Printf permet d'afficher du
texte structuré */
}
else /* Si j'arrive à mon dernier coup j'affiche que c'est le dernier coup */
{
nb_coup++;
printf ("nnttttX X X Xt Dernier Coup ntttt");
}
}
}
}

La fonction demande rejouer :
Cette fonction va nous permettre de recommencer une nouvelle partie si on le souhaite.
Lors de la demande de rejouer, si on répond par un o ou un O, alors je vais rejouer une partie et le
programme va se relancer en réinitialiser les paramètres vu précédemment.
Si on ne veut pas refaire une partie, le programme se ferme.
int demande_rejouer (void) /* Fonction de demande de rejouer à une nouvelle partie */
{
char touche; /* Déclaration de variable touche en caractère */
int rejouer; /* Déclaration de variable rejouer en entier */
printf ("nnVoulez-vous faire une nouvelle partie ?n-> "); /* Affichage Voulez-vous faire une nouvelle partie ? -> */
do
{
scanf("%c",&touche);
}
while(touche != 'o' && touche != 'O' && touche != 'n' && touche != 'N');
if (touche == 'o' || touche == 'O') /* Si je tappe o ou O alors je vais rejouer */
{
rejouer = OUI;
}
else /* Si je tappe n ou N je sors de la boucle */
{
rejouer = NON;
}
return rejouer;
}

Projet Mastermind

17

Le Mastermind.h :
Mastermind.h sert pour la définition des constantes et prototypes de sous programmes.
Dans ce fichier, on a déclaré toutes nos constantes que l’on utilise dans le main et le mastermind.c.
Il y a la déclaration des fonctions, mais aussi la déclaration de nos tableaux ou on stocke nos 4 chiffres
aléatoires et ceux que l’on va rentrer.
/*Sert pour savoir si les chiffres sont à la bonne place*/
#define Bonne_place
0
#define Mauvaise_place
1
#define Nombre_faux
2

//

bonne place
// mauvaise place
// nombre faux

/*Sert pour savoir si la combinaison à été trouvée*/
#define TROUVE
1
/*Sert pour savoir si le nombre de proposition est inférieur à 5*/
#define NB_PROPOSITION_MAX 5
/*Sert pour savoir si le joueur veut rejouer*/
#define OUI
0
#define NON
1

int action, partie; /* Variable globale */ /* Chaine de caractere codé sur 8bits */
int nb_choisi[4], nb_propose[4], nb_valide[4];
int nb_proposition, combi_trouve, nb_coup;
void initialisation (void);
void reinitialisation (void);
void demarrer_une_partie (void);
void affichage_depart (void);
void saisie_des_numeros (void);
void test_des_numeros (void);
void affichage (void);
int demande_rejouer (void);

Projet Mastermind

18

Mon programme en Console :
Première page, Nom du jeu, Aide, et première série :

Le programme est en attente, il attend qu’on saisisse les numéros entre 0 et 9.

Deuxième page : Saisie des numéros et affichage des numéros à leur bonne place :

Une fois notre série saisie, il nous indique quels numéros et à la bonne place ou mauvaise place.
Ici le 4 est à la mauvaise place et le 1, 2 et 3 ne sont pas dans la série cachée.
Projet Mastermind

19

3ème page :

Le 5, 7 et 8 n’apparaisse pas dans ma série cachée mais on a trouvé un bon numéro : le 6.

4ème page :

Donc il n’y a pas de 1, 2, 3, 5, 7, 8, 9 et 0 dans notre série cachée, il n’y a que le 6 et le 4.
En dernière position ce n’est pas possible de mettre le 4 car au premier coup on nous a indiqué que le 4 était
à la mauvaise place.
Projet Mastermind

20

5ème page :

Plus qu’une chance pour trouver notre série, en effet le 4 était placé qu’une seule fois dans notre série.

Dernière page :

La bonne combinaison a été trouvée, et la demande de rejouer apparait.

Projet Mastermind

21

Conclusion :
Ce projet m’a permis d’avoir une meilleure vision de l’informatique et du langage utilisé. Ce projet a été très
intéressant pour découvrir les divers aspects de la programmation.
En effet, dès le départ et au tout début du projet, j’étais très enthousiaste de découvrir une nouvelle matière.
Et tout au long du projet, je me suis rendu compte de la difficulté qu’on pouvait rencontrer.
Ce projet a été une expérience très enrichissante qui m’aidera dans ma future expérience professionnelle.

Projet Mastermind

22

Projet1 mastermind 2010-2011

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a Projet1 mastermind 2010-2011

Semelhante a Projet1 mastermind 2010-2011 (20)

Projet1 mastermind 2010-2011