Consignes pour les projets :

Numérique et sciences informatiques

start up

Projet 2 : Le pendu

Description du projet

Dans ce projet vous allez créer un programme permettant de jouer au jeu du pendu.

Il se joue à deux. L’un pense à un mot, par exemple :

L I C E N C E

et écrit une suite de tirets à la place des lettres :
_ _ _ _ _ _ _

L’autre doit deviner ce mot en ne connaissant au départ que sa longueur. Pour s’aider, il peut demander l’existence d’une lettre. A chaque lettre proposée, si celle-ci figure dans ` le mot, les occurrences de la lettre sont écrites à leur place. Par exemple, pour E :

_ _ _ E _ _ E

Si la lettre ne figure pas dans le mot, le joueur est pénalisé d’un point. Au bout de sept pénalisations, le joueur est « pendu » à moins qu’il ne trouve le mot avant. En général le jeu est agrémenté d’une sinistre potence dont le malheureux pendu se dessine progressivement à chaque mauvaise proposition.

Cahier des charges

Vous avez à votre disposition un fichier texte contenant une liste de mot (un peu plus de 800 mots)2_pendu_dico.txt [txt] et une fonction Python vous permettant de dessiner le pendu (voir ci-dessous)

def dessinPendu(nb):
    tab=[
    """
       +-------+
       |
       |
       |
       |
       |
    ==============
    """,
    """
       +-------+
       |       |
       |       O
       |
       |
       |
    ==============
    """
        ,
    """
       +-------+
       |       |
       |       O
       |       |
       |
       |
    ==============
    """,
    """
       +-------+
       |       |
       |       O
       |      -|
       |
       |
    ==============
    """,
    """
       +-------+
       |       |
       |       O
       |      -|-
       |
       |
    ==============
    """,
    """
       +-------+
       |       |
       |       O
       |      -|-
       |      |
       |
    ==============
    """,
    """
       +-------+
       |       |
       |       O
       |      -|-
       |      | |
       |
    ==============
    """
    ]
    return tab[nb]

Pour information les "triples guillemets" """ permettent de délimiter une chaîne de caractères située sur plusieurs lignes (chaîne de caractères multi-lignes).

Déroulement du programme

La machine organise le jeu.

  1. Le programme sélectionne un mot.
  2. Le mot s’affiche avec des blancs soulignés à la place des lettres.
  3. Le programme demande la saisie d’une lettre.
  4. Le second joueur tape une lettre.
    • En cas de succès, le mot s’affiche (avec les lettres trouvées).
    • En cas d’échec, le programme indique combien de propositions il reste.
  5. Le mot s’affiche avec des lettres et des soulignés selon qu’elles aient été découvertes ou non.
  6. Le programme reprend au point 3 sauf si le joueur a épuisé tous ses coups ou trouvé le mot.
A la fin de la partie, le programme affiche si le joueur est pendu ou non.

Le code du programme :

Entraînement 1 :

Écrivez la fonction choix_mot() qui sélectionne un mot à partir du fichier texte

def choix_mot(liste_mots):
  """ Fonction qui renvoie un mot du fichier texte source
  Paramètre :
    liste_mots : de type chaîne de caractère
  Retour :
    mot_inconnu : un mot du fichier, de type chaîne de caractère"""

Entraînement 2 :

Ecrivez une fonction verifier_saisie() qui doit vérifier si un caractère est comprise entre "A" et "Z". Il est possible d'utiliser le code ASCII pour transformer automatiquement les minuscules en majuscules. 

def verifier_saisie(caractere):
  """ Fonction qui renvoie True si caractere est compris entre "A" et "Z"
  Paramètre :
    caractere, de type chaîne de caractère
  Retour :
    Booléen"""

Entraînement 3 :

Écrivez une fonction cacher_mot() qui présente le mot à trouvé avec des undescores (_). 

def cacher_mot(mot):
  """ Fonction qui transforme mot_inconnu en une chaîne d'undescore (mot_cache)
  Paramètre :
    mot, de type chaîne de caractère
  Retour :
    mot_cache : chaîne de caractère avec des "_" . Cete chaîne à la même longueur que le paramètre mot"""

Entraînement 4 :

Écrivez une fonction verifier_lettre() qui vérifie la présence ou non de la lettre proposée dans le mot sélectionner. 

def verifier_lettre(mot,caractere):
  """ Fonction qui renvoie True si caractere est présent dans mot
  Paramètre :
    caractere, de type chaîne de caractère
    mot, de type chaîne de caractère
  Retour :
    Booléen"""

Entraînement 5 :

Ecrivez une fonction nb_erreur() qui compte le nombre d’erreurs du joueur. 

def nb_erreur(nb_erreur):
  """ Fonction qui comptabilise le nombre d'erreurs
  Paramètre :
    nb_erreur, de type int
  Retour :
    nb_erreur, de type int"""

Entraînement 6 :

Ecrivez une fonction potence() qui affiche la potence en fonction des essais. 

def potence(nb_erreur):
  """ Fonction qui affiche la potence en fonction du nombre d'erreurs
  Paramètre :
    nb_erreur, de type int
  """

Entraînement 7 :

Ecrivez une fonction lettre() qui affiche la lettre trouvée à la place de l'unduscore. 

def lettre(mot_inconnu,caractère):
  """ Fonction qui affiche la lettre trouvée à la place de l'unduscore de mot_inconnu
  Paramètre :
    caractere, de type chaîne de caractère
    mot_inconnu, de type chaîne de caractère
  Retour :
    mot_inconnu, de type chaîne de caractère"""

Entraînement 8 :

Écrivez une fonction deviner_mot() qui permet à un joueur de proposer des lettres jusqu’à ce qu’il trouve le mot à deviner ou qu’il ait épuisé ses maxima de propositions.

Entraînement 9 :

Écrivez une fonction score() qui permmette la gestion des scores (sur un fichier texte).

Le code du programme :

Amélioration 1 :

Afficher graphiquement les lettres déjà utilisé à l'écran.

Amélioration 2 :

Afficher le pendu avec des images à l'écran.