pendu

/* *************************************
* PROJET : JEU DU PENDU
* LABORATOIRE DE BASE DE PROGRAMMATION
* 1 IRT Groupe 2
* LEJEUNE SIMON
* ANNEE 2009-2010
*****************************************/
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>
#include <time.h>
 
void afficher_choix_menu();
void menu_jouer();
void choisir_motadeviner(char *ptr_motadeviner);
void afficher_potence(int *ptr_nbr_erreurs);
void recuperer_lettre(char *ptr_ltr_choisie, char *ptr_ltr_proposees);
void verifier_mot(char *ptr_motadeviner,int *ptr_motadeviner_bool, char *ptr_ltr_choisie, int *ptr_lng_motadeviner, int *nbr_erreurs);
void afficher_mot(int *ptr_motadeviner_bool, char *ptr_motadeviner, int *ptr_lng_motadeviner);
void menu_afficherregles();
 
int main()
{
    afficher_choix_menu();   //Appelle la procédure MENU qui affiche les possibilités du menu
 
    int choix_menu;
    do
    {
        scanf("%d",&choix_menu);
        fflush(stdin);
    }
    while (choix_menu<1 || choix_menu>3); //Redemande de saisir un numéro tant qu'il est différent de 1, 2 ou 3.
 
    switch (choix_menu) //Switch qui envoir l'user sur la procédure de son choix
    {
    case 1:
        menu_jouer();
        break;
    case 2:
        menu_afficherregles();
        break;
    case 3:
        exit(0);
        break;
    default :
        printf("Valeur incorrecte");
        break;
    }
 
    return 0;
}
/*------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------*/
void afficher_choix_menu()
{
    system("cls");
 
    printf("-----------------------------------------\n");
    printf("Programme realise par : LEJEUNE Simon\n");
    printf("Section : 1IRT Groupe : 2\n");
    printf("Annee academique : 2009-2010\n");
    printf("Nom de l'enseignant : Tricarico - De Bodt\n");
    printf("Projet : Jeu du Pendu\n");
    printf("-----------------------------------------\n\n");
 
    printf("===== MENU =====\n\n(1) : Jouer\n(2) : Regles du jeu\n(3) : Quitter\n\nQue voulez-vous faire ?\n");
}
/*------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------*/
void menu_jouer()
{
    char motadeviner[40],ltr_proposees[26] = "0000000000000000000000000",ltr_choisie; // initialisation du tableau LTR_PROPOSEES à 0 pour éviter que des valeurs aléatoires prennent la place de lettres.
    int lng_motadeviner,i,motadeviner_bool[40];
    //Initialisation
    choisir_motadeviner(motadeviner);
    //
    lng_motadeviner=strlen(motadeviner);
 
    //Remplissage du motadeviner_bool entièrement par des 0
    for (i=0;i<lng_motadeviner;i++)
        motadeviner_bool[i]=0;
 
    int nbr_erreurs=0,j=0,y;
    system("cls");
    do
    {
        system("cls");
 
        afficher_potence(&nbr_erreurs); //Appelle la procédure qui affiche la potence
        printf("\n\n\n");
 
        printf("Les lettres deja choisies sont : ");
        for (y=0;y<j;y++)   //Passe par toutes les cellules /!\utilisées/!\ du tableau LTR_PROPOSEES
            printf("%c ",ltr_proposees[y]);
 
        printf("\nNombres de fautes : %d",nbr_erreurs);
 
        afficher_mot(motadeviner_bool,motadeviner,&lng_motadeviner); //Appelle la procédure pour l'affichage du mot caché
        //et vérifie si le mot est deviné avant le décompte d'erreurs
        recuperer_lettre(&ltr_choisie,ltr_proposees);   //Appelle la procédure qui permet d'enregistrer les lettres
        ltr_proposees[j]=ltr_choisie;   //Enregistre la lettre entrée précédemment dans le tableau LTR_PROPOSEES
        j++;    //Incrémente l'accumulateur qui va permettre d'enregistrer la lettre à partir de la première cellule du tableau LTR_POPOSEES
 
        verifier_mot(motadeviner,motadeviner_bool,&ltr_choisie,&lng_motadeviner,&nbr_erreurs); //Appelle la fonction qui vérifie et modifie le mot caché
    }
    while (nbr_erreurs<7);
 
    printf("\n\n\nVous avez echoue car vous avez fait 7 erreurs.\nAppuyer sur une touche pour retourner au menu.."); //Si le do while se termine, c'est forcément que l'user a fait trop d'erreurs
    getch();
    main();
}
/*------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------*/
void choisir_motadeviner(char *ptr_motadeviner)
{
    char mot_genere[10][40];
    int ind_mot_genere;
 
    srand (time(NULL));
    ind_mot_genere=rand()%10; // Génere un indice entre 0 et 9 afin de choisir un des mots
 
    strcpy (mot_genere [0],"oreille");
    strcpy (mot_genere [1],"salopette");
    strcpy (mot_genere [2],"ukraine");
    strcpy (mot_genere [3],"belgique");
    strcpy (mot_genere [4],"or");
    strcpy (mot_genere [5],"calcul");
    strcpy (mot_genere [6],"bouteille");
    strcpy (mot_genere [7],"cylindre");
    strcpy (mot_genere [8],"carre");
    strcpy (mot_genere [9],"television");
 
    //Copier le mot choisi dans le pointeur mot_adeviner
    strcpy (ptr_motadeviner, mot_genere[ind_mot_genere]);
}
/*------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------*/
void afficher_potence(int *ptr_nbr_erreurs)
{
    switch (*ptr_nbr_erreurs) //Afficher tel dessin en fonction du nombre d'erreus
    {
    case 0:
        printf("_____________\n");
        printf(" |\n");
        printf(" |\n");
        printf(" |\n");
        printf(" |\n");
        printf(" |\n");
        printf("_|____________\n");
        break;
 
    case 1:
        printf("_____________\n");
        printf(" | /\n");
        printf(" |/\n");
        printf(" |\n");
        printf(" |\n");
        printf(" |\n");
        printf("_|____________\n");
        break;
 
    case 2:
        printf("_____________\n");
        printf(" | /       |\n");
        printf(" |/\n");
        printf(" |\n");
        printf(" |\n");
        printf(" |\n");
        printf("_|____________\n");
        break;
 
    case 3:
        printf("_____________\n");
        printf(" | /       |\n");
        printf(" |/        O\n");
        printf(" |\n");
        printf(" |\n");
        printf(" |\n");
        printf("_|____________\n");
        break;
 
    case 4:
        printf("_____________\n");
        printf(" | /       |\n");
        printf(" |/        O\n");
        printf(" |         |\n");
        printf(" |\n");
        printf(" |\n");
        printf("_|____________\n");
        break;
 
    case 5:
        printf("_____________\n");
        printf(" | /       |\n");
        printf(" |/        O\n");
        printf(" |        -|-\n");
        printf(" |\n");
        printf(" |\n");
        printf("_|____________\n");
        break;
 
    case 6:
        printf("_____________\n");
        printf(" | /       |\n");
        printf(" |/        O\n");
        printf(" |        -|-\n");
        printf(" |         /\\\n");
        printf(" |\n");
        printf("_|____________\n");
        printf("\n\nDerniere chance..\n");
        break;
 
    default:
        printf("Valeur incorrecte");
        break;
    }
}
/*------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------*/
void recuperer_lettre(char *ptr_ltr_choisie, char *ptr_ltr_proposees)
{
    int ascii_ok=0,i;
    do
    {
        printf("Choisissez une lettre : ");
        scanf("%c",ptr_ltr_choisie);
        fflush(stdin);
 
        if (*ptr_ltr_choisie>=97 && *ptr_ltr_choisie<=122) //Restreint les lettres proposées de a à z (code ascii).
            ascii_ok=1; //Le choix s'effectue avec succés
        else
            printf("\nVous avez introduit un caractere non autorise.\n");
 
        for (i=0;i<26;i++)//Passe par toutes les cellules du tableau LTR_PROPOSEES
        {
            if (ptr_ltr_proposees[i] == *ptr_ltr_choisie)   //Rappelle a l'utilsateur si il a déjà enregistré la lettre dans LTR_PROPOSEE.
            {
                printf("\nVous avez ddeja introduit cette lettre.\n");
                ascii_ok=0; //Problème dans le choix
            }
        }
    }
    while (ascii_ok==0);    //Tourne tant qu'il y aura un problème dans le choix
}
/*------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------*/
void verifier_mot(char *ptr_motadeviner,int *ptr_motadeviner_bool, char *ptr_ltr_choisie, int *ptr_lng_motadeviner, int *nbr_erreurs)
{
    int i,bonne_reponse=0;  //Le booleen BONNE_REPONSE permet de savoir si LTR_CHOISIE est comprise dans le MOTADEVINER
 
    for (i=0;i<*ptr_lng_motadeviner;i++)    //Permet de passer par toutes les cellules du tableau MOTADEVINER
    {
        if (ptr_motadeviner[i] == *ptr_ltr_choisie) //Compare les cellules avec LTR_CHOISIE
        {
            ptr_motadeviner_bool[i]=1;  //LTR_CHOISIE est comprise dans le mot, le booleen correspondant vaut à présent 1
            bonne_reponse=1;            //Cette variable permet de faire une condition sur son cas contraire, afin d'incrémenter le nombre d'erreurs.
        }
    }
 
    if (bonne_reponse==0)
        (*nbr_erreurs)++;   //LTR_CHOISIE ne fait pas partie du MOTADEVINER, on incrémente le nombre d'erreur.
}
/*------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------*/
void afficher_mot(int *ptr_motadeviner_bool, char *ptr_motadeviner, int *ptr_lng_motadeviner)
{
    /* Pour afficher l'état actuel du mot recherché, on fait un for pour passer par toutes les cellules du tableau MOTADEVINER et
       MOTADEVINER_BOOL. Si le booléen correspondant à une lettre est à 1 on affiche la lettre, si il est à 0 on affiche une étoile.*/
    int i;
    printf("\n\n");
    for (i=0;i<*ptr_lng_motadeviner;i++)
    {
        if (ptr_motadeviner_bool[i] == 1)
            printf("%c",ptr_motadeviner[i]);
        else
            printf("*");
    }
    printf("\n\n");
 
    //Vérifier si le mot est correct
 
    /*  Pour savoir si tous les booleens de MOTADEVINER_BOOL sont a 1, on le compare avec le nombre de lettres
        du mot original à deviner. Par exemple dans le cas du mot "pendu", si l'utilisateur a entré les lettres
        "p-e-n-d-u", le MOTADEVINER_BOOL ezst uniquement composé de 1 ; on doit donc avoir une somme de booleens
        "1-1-1-1-1- égale au nombre de lettres de "pendu", ce qui donne 5 des deux côtés.*/
    int somme=0,j;
 
    for (j=0;j<*ptr_lng_motadeviner;j++)
        somme += ptr_motadeviner_bool[j];
 
    if (somme == *ptr_lng_motadeviner)
    {
        printf("Gagne !");
        ; //Si la somme est égale au nombre de lettres, ona la bonen réponse et on renvoie 1
        printf("\n\nLe mot etait bien  : %s",ptr_motadeviner);
        printf("\n\n\nAppuyer sur une touche pour retourner au menu..");
        getch();
        main();
    }
 
}
/*------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------*/
void menu_afficherregles()
{
    system("cls");
    printf("---Les regles du penu---\n\n");
    printf("Le pendu est un jeu consistant a retrouver un mot en devinant quelles \nsont les lettres qui le ");
    printf("composent. Le jeu se joue traditionnellement a\ndeux, avec un papier et un crayon, selon un ");
    printf("deroulement bien particulier.\n\nDans ce programme, l'ordinateur va se");
    printf("substituer a l'un des joueurs. \nL'utilisateur doit deviner un mot choisi au hasard par l'ordinateur en ");
    printf("un \nminimum d'essais. Pour cela, il propose des lettres de l'alphabet. Si \nla lettre figure dans le mot a ");
    printf("trouver, elle s'affiche. Si elle n'y figure \npas, le nombre des mauvaises reponses augmente de 1, ce ");
    printf("qui se materialise \npar une evolution du dessin de la silhouette du personnage. \n\nAu bout de sept ");
    printf("mauvaises reponses, la partie est perdue.");
    printf("\n\n\nAppuyer sur un touche pour retourner au menu..");
    getch();//Permet de mettre le système en pause
    main(); //Rappelle le main pour accéder au menu
}