Algorithme 
Projet N2 : Pendu


Rsultat : 
   Afficher le vainqueur d'un jeu de pendu entre deux joueurs lorsque ceux-ci dcident de ne 
plus faire de nouvelle manche, sachant qu'une manche se dcompose en deux phases.
1.	le premier joueur propose un mot  deviner et le second doit deviner le mot.
2.	le second joueur propose un mot  deviner et le premier doit deviner le mot. 
      
Ide de lalgorithme :
-	Initialiser les scores
-	Boucle de manche
o	Boucle de phase
		Le joueur 1 entre un mot
		Masquer les caractres de ce mot
		Boucle de jeu
		*	Le joueur 2 entre une lettre
		*	Si cette lettre est comprise dans le mot donn par le joueur 1, on 
			affiche cette lettre dans le mot, sinon on augmente le nombre 
			d'erreur de 1
		*	Si le mot est affich en entier, alors on augmente le score du 
			joueur 1 de 1, sinon si le nombre total d'erreur est gal  11, on 
			augmente le score du joueur 2 de 1, sinon on recommence la 
			boucle de jeu.
		On recommence la phase en inversant les deux joueurs.
o	Si les joueurs le dsirent, on recommence une nouvelle manche
-	Affichage des score et dsignation du vainqueur.


Lexique des fonctions :
-	fonction estMotValide(in mot : chane) : ret boolen 
/* Renvoie VRAI si le mot  tester ne comporte que des lettres */
-	fonction estCarValide(in car : caractre) : boolen 
/* Renvoie VRAI si un caractre est une lettre comprise entre [a-z] ou [A-Z] */
-	fonction lettreMaj(in-out car : caractre) : vide 
/* Converti une lettre en majuscule */
-	fonction motMaj(in-out mot : chane) : vide 
/* Converti une chane en majuscule */
-	fonction afficheEcran(in phase : entier, in nbErreur : entier, in mot : chane, in score1 : 
entier, in score2 : entier) : vide 
/* Affiche sur l'cran les informations du jeu */

Lexique des constantes : 

NOM TYPE VALEUR DESCRIPTION
MAX_FAUTES (entier) =11 Nombre de fautes maximums.
CACHE (caractre) ='_' Caractre masquant les lettres
DESSIN_PENDU (chane tableau[7]) 		={"  _____  ","  |/  |  ",  	Dessin du pendu  afficher
						"  |   O  ","  |  -+- ",
						"  |  / \\","  |      ",
						" ---     "}			 
VAL_DESSIN (entier tableau tableau[7][9]) 	={{0,0,4,4,4,4,4,0,0},{0,0,2, 	Tableau contenant le nombre de fautes 
						3,0,0,5,0,0},{0,0,2,0,0,0,6,0, 	 partir desquelles on affiche chaque 
						0},{0,0,2,0,0,8,7,9,0},{0,0,2 	caractre du pendu
						,0,0,10,0,11,0},{0,0,2,0,0,0,
						0,0,0},{0,1,1,1,0,0,0,0,0}}

NB_CASE_TAB (entier) =63 Nombre de case dans VAL_DESSIN
 
Lexique des variables :

NOM TYPE DESCRIPTION ROLE
mot (chane) Mot entr par le joueur. DONNE
motMasque (chane) Mot entr par le joueur masqu. RSULTAT
i (entier) Compteur de boucle. INTERMEDIARE
carLu (caractre) Caractre entr par le joueur. DONNE
carTrouve (boolen) Indique si le caractre existe dans le mot. INTERMEDIARE
phase (entier) Numro de la phase en cour. INTERMEDIARE
nbErreur (entier) Nombre d'erreur commise par le joueur. RSULTAT
perdu (boolen) Indique si le joueur a perdu. INTERMEDIARE
gagne (boolen) Indique si le joueur a gagn. INTERMEDIARE
score1 (entier) Score du joueur 1. RSULTAT
score2 (entier) Score du joueur 2. RSULTAT
nouvManche (chane) Indique si une nouvelle manche doit tre cre. INTERMEDIARE

Algorithme :
score1 <- 0
score2 <- 0
system("clear")
rpter
   pour phase de 1  2
      nbErreur <- 0
      perdu <- faux
      gagne <- faux
      mot <- lire
      repeter
   mot <- lire 
tant que estMotValide(mot)=faux
mojMaj(mot)
      motMasque <- mot
      pour i de 0  mot.length() - 1
         motMasque[i] <- CACHE
      fpour
      afficherEcran(phase,nbErreur,motMasque,score1,score2)
      rpter 
         repeter
            carLu <- lire
         tant que estCarValide(carLu)=faux
         lettreMaj(carLu)
         carTrouve <- faux
         pour i de 0  mot.length()
            si mot[i] = carLu alors
               motMasque[i] <- carLu
               carTrouve <- vrai
            fsi
         fpour
         si carTrouve = faux alors
            nbErreur <- nbErreur + 1
            si nbErreur = MAX_FAUTES alors
               perdu <- vrai
            fsi
         fsi
         gagne <- vrai
         pour i de 0  mot.length() - 1
            si motMasque[i] = "_" alors
               gagn <- faux
            fsi
         fpour
         afficherEcran(phase,nbErreur,motMasque,score1,score2)
      tant que perdu = faux et gagne = faux
      si perdu = vrai alors
         si phase = 1 alors
            score2 <- score2 + 1
         sinon
            score1 <- score1 + 1
         fsi
      sinon
         si phase = 2 alors
            score2 <- score2 + 1
         sinon
            score1 <- score1 + 1
         fsi
      fsi
      crire score1, score2
   fpour
   nouvManche <- lire
tant que nouvManche = "oui" 
system("clear")
crire score1, score2
si score1<score2 alors
   crire "joueur 2 gagne" 
sinon
   si score2<score1 alors
      crire "joueur 1 gagne"
   sinon
      crire "match nul"
   fsi
fsi

Dclarations des fonctions :

Fonction : fonction estMotValide(in mot : chaine) : ret boolen 
Commentaire : /* Renvoie VRAI si le mot  tester ne comporte que des lettres */
Lexique local des variables :
NOM TYPE DESCRIPTION ROLE
i (entier) Compteur de la boucle. INTERMEDIARE
valide (boolen) Indique si le mot est valide. INTERMEDIARE
Algorithme de estMotValide :
valide <- vrai
pour i de 0  mot.length() - 1
   si estCarValide(mot[i])=faux alors
      valide <- faux
   fsi
fpour
si valide=vrai alors 
   retour_de_estMotValide <- vrai
sinon
   retour_de_estMotValide <- faux
fsi

Fonction : fonction estCarValide(in car : caractre) : ret boolen 
Commentaire : /* Renvoie VRAI si un caractre est une lettre comprise entre [a-z] ou [A-Z] 
*/
Algorithme de estCarValide :
si (car>='a' et car<='z') ou (car>='A' et car<='Z') alors 
   retour_de_estCarValide <- vrai
sinon
   retour_de_estCarValide <- faux
fsi

Fonction : afficheEcran(in phase : entier, in nbErreur : entier, in mot : chane, in score1 : 
entier, in score2 : entier) : vide 
Commentaire : /* Affiche sur l'cran les informations du jeu */
Lexique local des variables :
NOM TYPE DESCRIPTION ROLE
i (entier) Compteur de la boucle. INTERMEDIARE
numLig (entier) Numro de la ligne courante dans le tableau INTERMEDIARE
numCol (entier) Numro de la colonne courante dans le tableau INTERMEDIARE
Algorithme de afficheEcran :
system("clear")
crire "Joueur "
si phase=1 alors
   crire "2"
sinon
   crire "1"
fsi
crire "Score joueur 1 : ", score1
crire "Score joueur 2 : ", score2
numLig <- 0
numCol <- 0
pour i de 0  NB_CASE_TAB
si VAL_DESSIN[numCol][numLig]<=nbErreur alors
   crire DESSIN_PENDU[numCol][numLig]
sinon
   crire " "
sinon
   si numLig=8 alors
      crire "\n"
      numLig <- 0
      numCol <- numCol+1
   sinon
      numLig <- numLig+1
   fsi
fsi
crire mot

Fonction : fonction motMaj(in-out mot : chane) : vide 
Commentaire : /* Converti une chane en majuscule */
Lexique local des variables :
NOM TYPE DESCRIPTION ROLE
i (entier) Compteur de la boucle. INTERMEDIARE
Algorithme de motMaj :
pour i de 0  mot.length()-1
      carMaj(mot[i])
fpour

Fonction : fonction lettreMaj(in-out car : caractre) : vide 
Commentaire : /* Converti un caractre en majuscule */
Algorithme de lettreMaj :
si car>='a' et car<='z' alors
   car <- car + 'A' - 'a'
fsi

