Le pendu

/* *************************************
* 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;
 
    case 1:                     // Cas où 1 faute a été commise => évolution du dessin
    printf("--------------\n");
    printf(" | \n");
    printf(" |\n");
    printf(" |\n");
    printf(" |\n");
    printf(" |\n");
    printf("//////////////");
    break;
 
    case 2:
    printf("--------------\n");
    printf(" |        |\n");
    printf(" |\n");
    printf(" |\n");
    printf(" |\n");
    printf(" |\n");
    printf("//////////////");
    break;
 
    case 3:
    printf("--------------\n");
    printf(" |        |\n");
    printf(" |        @\n");
    printf(" |\n");
    printf(" |\n");
    printf(" |\n");
    printf("//////////////");
    break;
 
    case 4:
    printf("--------------\n");
    printf(" |         |\n");
    printf(" |         @\n");
    printf(" |         |\n");
    printf(" |\n");
    printf(" |\n");
    printf("//////////////");
    break;
 
    case 5:
    printf("--------------\n");
    printf(" |         |\n");
    printf(" |         @\n");
    printf(" |        -|-\n");
    printf(" |\n");
    printf(" |\n");
    printf("//////////////");
    break;
 
    case 6:
    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;
    }
}
//______________________________________________________________________________________________________________