Le pendu

by Ilias on December 28th, 2009

No notes

Syntax: C

Show lines - Hide lines - Show in textbox - Download

/* *************************************
* PROJET : JEU DU PENDU
* LABORATOIRE DE BASE DE PROGRAMMATION
* 1 section groupe
* Akkan Ilias
* ANNEE 2009-2010
*****************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <ctype.h>

void afficherMenu();
void regles();
void jeu();
void initialisation(char *pt_motMystere);
void afficherPotence(int *nbreErreur);
void recupererLettre(char *lettreSaisie, char *lettresDejaProposees);
void afficherMotPotence(int *booleenMot, char *motCache, int *nbreLettre);
void verifierLettreMot(char *motMasque, int *booleenMotMasque, char *lettreEntree, int *longueurMot, int *nbErreur);
void afficherResultat(int *booleeMotTrouve, int *booleenMotInconnu, int *longueurMotInconnu);

int main()
{
    int choixMenu;

do
    {
    afficherMenu(); // Appel de la procédure afficherMenu
    scanf("%d", &choixMenu);
    fflush(stdin); // Vide la saisie (pour éviter les sources d'erreurs)
    }
    while(choixMenu != 1 && choixMenu != 2 && choixMenu != 3); // Tant que la saisie de l'utilisateur est différente de 1, 2 et 3, le menu s'affiche et demande une saisie à nouveau

switch (choixMenu) // Structure de sélection multiple permettant à l'utilisateur de faire un choix parmi les 3 posibilités
    {
        case 1:
            jeu();
        break;

case 2:
            regles();
        break;

case 3:
            printf("\nAu revoir.\n");
        break;

default:
            printf("Erreur\n");
        break;
    }

return 0;
}

void afficherMenu() // Il s'agit d'une procédure car elle ne sert qu'à l'affichage du menu
{
    system("cls"); // Effacement du contenu de la console (nouvelle page si on veut)
    printf("-----------------------------------------\n");
    printf("Programme realise par Ilias Akkan\n");
    printf("Section : 1IRT    Groupe : 1\n");
    printf("Annee academique : 2009-2010\n");
    printf("Nom de l'enseignant : M. J. De Bodt\n");
    printf("Projet : Jeu du Pendu\n");
    printf("-----------------------------------------\n\n");
    printf("====== MENU ======\n\n");
    printf("1. Jouer\n2. Regles du jeu\n3. Quitter\n\nFaites un choix : ");
}
//______________________________________________________________________________________________________________

void regles() // Affichage des règles du pendu
{
    system("cls");
    printf("\t====== Regles du pendu ======\n\n");

printf("\nLe pendu est un jeu consistant a retrouver un mot en devinant quelles \nsont les lettres qui le composent. Le jeu se joue traditionnellement a\ndeux, avec un papier et un crayon, selon un ");
    printf("deroulement bien particulier.\n\nIci, l'ordinateur va se substituer a l'un des joueurs. L'utilisateur doit\ndeviner un mot choisi au hasard par l'ordinateur en un minimum d'essais.\n");
    printf("Pour cela, il propose des lettres de l'alphabet. Si la lettre figure dans\nle mot a trouver, elle s'affiche. Si elle n'y figure pas, le nombre de\nmauvaises reponses augmente de 1, ce ");
    printf("qui se materialise par une evolution\ndu dessin de la silhouette du personnage.\n\nAu bout de sept mauvaises reponses, la partie est perdue.");

printf("\n\n\n\nAppuyez sur n'importe quelle touche pour retourner a l'ecran principal...");

getch(); // Mise en pause du programme
    main(); // Renvoie la procédure au programme principal (main)
}
//______________________________________________________________________________________________________________

void jeu() // Comme le module jeu contient des modules qui lui sont propres, je décide d'utiliser le même nom de variable que ses sous-modules pour éviter des problèmes d'ambiguïté
{
    char motSecret[15], lettresDejaProposees[22] = {0}, lettreSaisie;
    int jeu_nbreLettre, i, jeu_booleenMot[40], nbreErreur = 0, j = 0, booleenMotTrouve, k;

initialisation(motSecret); // Appel de la procédure initialisation générant des mots aléatoires

jeu_nbreLettre = strlen(motSecret); // Détermination de la longueur du mot caché

for (i = 0; i < jeu_nbreLettre; i++)
    {
        jeu_booleenMot[i] = 0; // Remplacement du mot à deviner par des * (voir procédure afficherMotPotence)
    }
    system("cls");

do
    {
        system("cls");

afficherPotence(&nbreErreur); // Affichage de la potence
        printf("\n");

afficherMotPotence(jeu_booleenMot, motSecret, &jeu_nbreLettre); // Affichage du mot caché situé sous la potence

printf("Lettres deja proposees :\n\t");
        for (k = 0; k < j; k++)
        {
            printf("%c ", lettresDejaProposees[k]);
        }

printf("\n\nFautes commises : %d", nbreErreur);

recupererLettre(&lettreSaisie, lettresDejaProposees); // Récupération des lettres saisies par l'utilisateur

lettresDejaProposees[j] = lettreSaisie; // Copie et affichage des lettres saisies dans le tableau des lettres déjà proposées
        j++;

verifierLettreMot(motSecret, jeu_booleenMot, &lettreSaisie, &jeu_nbreLettre, &nbreErreur); // Vérification des lettres saisies et du mot à trouver

afficherResultat(&booleenMotTrouve, jeu_booleenMot, &jeu_nbreLettre); // Fin du jeu et affichage du mot caché
    }
    while (booleenMotTrouve != 1 && nbreErreur < 7); // Tant que le nombre d'erreur est < à 7 et que le mot caché n'a pas été trouvé, le jeu continue

if (nbreErreur > 6)
        {
            printf("\n\n\nVous avez perdu. Le mot a trouver etait \"%s\".\n\nAppuyer sur une touche pour retourner au menu principal...", motSecret);
            getch();
            main();
        }

else
        {
            printf("\n\nFelicitations! Vous avez trouve le mot \"%s\".", motSecret);
            printf("\n\n\nAppuyez sur n'importe quelle touche pour retourner au menu principal...");
            getch();
            main();
        }
}
//______________________________________________________________________________________________________________

void initialisation(char *pt_motMystere) // Procédure générant de manière aléatoire le mot pour la suite du jeu
{                          // *pt_motMystere est un pointeur contenant une chaine de caractère qui est le mot à trouver

char motsPossibles[13][20]; // Tableau de chaine de caractères contenant tous les mots générés
    int nbreHasard;

srand (time(NULL)); // Initialisation du générateur de nombres aléatoires
    nbreHasard = rand() % 13; // Génere un nombre entre 0 et 12

strcpy (motsPossibles [0], "maison");
      strcpy (motsPossibles [1], "trompette");
      strcpy (motsPossibles [2], "amertume");
      strcpy (motsPossibles [3], "hachoir");
      strcpy (motsPossibles [4], "omnipresent");
      strcpy (motsPossibles [5], "xylophone");
      strcpy (motsPossibles [6], "zebre");
      strcpy (motsPossibles [7], "appartement");
      strcpy (motsPossibles [8], "horoscope");
      strcpy (motsPossibles [9], "crepuscule");
      strcpy (motsPossibles [10], "bicyclette");
      strcpy (motsPossibles [11], "sternum");
      strcpy (motsPossibles [12], "amphibien");

strcpy (pt_motMystere, motsPossibles[nbreHasard]); // Affection du mot généré au hasard dans la variable pt_motMystere
}
//______________________________________________________________________________________________________________

void afficherPotence(int *nbreErreur) // Affichage de la potence au lancement du jeu
{
    switch(*nbreErreur)
    {
    case 0:                     // Début du jeu, 0 faute commise
    printf("--------------\n");
    printf(" |\n");
    printf(" |\n");
    printf(" |\n");
    printf(" |\n");
    printf(" |\n");
    printf("//////////////");
    break;

default:
    break;
    }
}
//______________________________________________________________________________________________________________

void recupererLettre(char *lettreSaisie, char *lettresDejaProposees)
{
    /* L'utilisateur va ici proposer un caractère pour trouver le mot caché, on considère que le mot à trouver est composé uniquement de lettres et non de caractères spéciaux tels que la ponctuation
       Donc, on va restreindre le choix des caractères en se référant à la table des codes ASCII. */

int codeASCII=0,i;
    do
    {
        printf("\n\nChoisissez une lettre : ");
        scanf("%c", lettreSaisie); // Etant donné que la variable est un pointeur et qu'un pointeur pointe déjà à une adresse, mettre un & ferait double emploi
        fflush(stdin);

if (*lettreSaisie >= 97 && *lettreSaisie <= 122) // Restriction des lettres minuscules de l'alphabet de a à z
        {
            codeASCII = 1; // La lettre saisie fait partie de notre restriction, donc tout va bien
        }

else
        {
            printf("\nVous avez introduit un caractere non autorise.\n");
        }

// On va rappeller à l'utilisateur à l'aide d'un bip sonore si il a déjà entré une même lettre

for (i = 0; i < 26; i++)
        {
            if (lettresDejaProposees[i] == *lettreSaisie)
            {
                printf("\a"); // Bip car lettre proposée déjà proposée
                codeASCII = 0; // On reste dans la boucle afin que le programme demande à nouveau à l'utilisateur de taper une autre lettre
            }
        }
    }
    while (codeASCII == 0); // On ne sort de la boucle que lorsque l'utilisateur a entré un caractère valide et pas 2 fois le même caractère
}
//______________________________________________________________________________________________________________

void afficherMotPotence(int *booleenMot, char *motCache, int *nbreLettre) // Affichage du mot caché situé sous la potence lors du jeu
{
    printf("\n\n\t");

int i;

for (i=0;i<*nbreLettre;i++) // On parcourt toutes les cases du mot, pour savoir s'il faut afficher ou non les lettres cachées

{
        if (booleenMot[i] == 1) // Si la lettre figure dans le mot à trouver, on l'affiche
        {
            printf("%c",motCache[i]);
        }

else // Si la lettre ne figure pas dans le mot à trouver, on afficher un *
        {
            printf("*");
        }
    }
    printf("\n\n");
}
//______________________________________________________________________________________________________________

void verifierLettreMot(char *motMasque,int *booleenMotMasque, char *lettreEntree, int *longueurMot, int *nbErreur)
{
    // La variable vérification va nous permettre de savoir si la lettre tapée est incluse dans le mot caché

int i, verification = 0;

for (i = 0; i < *longueurMot; i++) // On parcout toutes les cases du mot
    {
        if (motMasque[i] == *lettreEntree) // Si la lettre entrée est incluse dans le mot à trouver,
        {
            booleenMotMasque[i] = 1;  // Tout va bien et on affecte la valeur 1 au booleen
            verification = 1;         // Ainsi qu'à la variable vérification
        }
    }

if (verification == 0) // Si la lettre n'est pas comprise dans le mot à chercher, le nombre d'erreurs augmente de 1
    {
        (*nbErreur)++;
    }
}
//______________________________________________________________________________________________________________

void afficherResultat(int *booleenMotTrouve, int *booleenMotInconnu, int *longueurMotInconnu)
{
    /* Ce module va afficher le mot à trouver peu importe les circonstances du jeu (partie perdue ou gagnée).
       L'idée est de remplir toutes les cases du booleen à 1 pour afficher toutes les lettres du mot caché */

int somme = 0,i;

for (i = 0; i < *longueurMotInconnu; i++)
    {
        somme = somme + booleenMotInconnu[i]; // Accumulateur faisant la somme de tous les 1 correspondants au nombre de lettres du mot à deviner
    }

if (somme == *longueurMotInconnu) // Si la somme vaut le même nombre de lettres que le mot à trouver, c'est bon !
    {
        *booleenMotTrouve = 1; // On remplit les cases de 1
    }
    else
    {
        *booleenMotTrouve = 0;
    }
}
//______________________________________________________________________________________________________________

Le pendu

Leave a Reply