Défi "Hangman"

Pour ceux qui ont de l'avance en programmation python, voici un défi à réaliser en autonomie (une fois s'être assuré de savoir faire les TD des chapitres A à E !). Il s'agit de programmer le jeu du pendu (ou "hangman" en anglais).

Les notions qu'il faudra utiliser pour ce projet sont :

• Les fonctions
• Les listes
• Les boucles while et for
• Les conditions if et else
• Les chaînes de caractères
• Les entrées/sorties (input/output)
• Les dictionnaires
• ...

Ce sera aussi l'occasion de faire une escapade dans le monde le l'ASCII ART, c'est à dire l'art de dessiner avec des caractères ASCII (c'est à dire des lettres, des chiffres et des symboles).

Le principe du jeu est simple : un mot est choisi au hasard, et le joueur doit deviner les lettres du mot. À chaque erreur, une partie du pendu est dessinée. Le joueur gagne s'il trouve le mot avant que le pendu soit entièrement dessiné.

Exemple de déroulement du jeu

Les lignes mises en évidence concernent les entrées de l'utilisateur (les lettres devinées) :

H A N G M A N
+---+
|   |
    |
    |
    |
    |
=========
Lettres manquées :
_ _ _
Devine une lettre :
a
+---+
|   |
    |
    |
    |
    |
=========
Lettres manquées :
_ a _
Devine une lettre :
o
+---+
|   |
O   |
    |
    |
    |
=========
Lettres manquées : o
_ a _
Devine une lettre :
r
+---+
|   |
O   |
|   |
    |
    |
=========
Lettres manquées : or
_ a _
Devine une lettre :
t
+---+
|   |
O   |
|   |
    |
    |
=========
Lettres manquées : or
_ a t
Devine une lettre :
a
Tu as déjà choisi cette lettre, prends-en une autre !
Devine une lettre :
r
Bravo, tu as trouvé le mot secret qui était "rat".
Do you want to play again ? (yes/no)
no  

Le diagramme représentant l'algorithme du jeu

Il n'est pas toujours nécessaire de dessiner « Flow Chart ». Nous pouvons simplement démarrer à écrie du code. Mais souvent, pendant la programmation, nous allons penser à des choses à ajouter ou à changer que nous n'avions pas envisagées auparavant. Nous pourrions finir par devoir modifier ou supprimer beaucoup de code que nous avions déjà écrit, ce qui serait une perte de temps. Pour éviter cela, il est toujours préférable de réfléchir attentivement et de planifier le fonctionnement du programme avant de commencer à écrire du code.

Pour vous aider à réfléchir, on vous propose un diagramme représentant l'algorithme du jeu attendu (un peu d'anglais, mais c'est facile à comprendre ):

Al Sweigart, l'auteur du livre dont est tiré ce défi écrit lui-même :

It may seem like a lot of work to sketch out a flow chart about the program first. After all, people want to play games, not look at flowcharts! But it is much easier to make changes and notice problems by thinking about how the program works before writing the code for it. If you jump in to write the code first, you may discover problems that require you to change the code you've already written. Every time you change your code, you are taking a chance that you create bugs by changing too little or too much. It is much better to know what you want to build before you build it.

Les étapes à suivre

Création des dessins

On crée une variable HANGPICS qui sera une liste contenant les différentes étapes du dessin du pendu. Chaque image sera une chaîne de caractères ASCII représentant le pendu à différents stades de son dessin. (Remarque : cette variable ne sera pas modifiée pendant le jeu, on peut l'appeler constante, l'usage en Python est de l'écrire en majuscules pour indiquer qu'elle ne doit pas être modifiée.)

On donne le début de cette variable, à vous d'imaginer la suite:

HANGPICS = ['''
  +---+
  |   |
      |
      |
      |
      |
=========''', '''
  +---+
  |   |
  O   |
      |
      |
      |
=========''',

# à compléter

]

Création de la liste des mots

On crée une variable WORDS qui sera une liste contenant les mots à deviner. On peut commencer par quelques mots simples, puis en ajouter d'autres au fur et à mesure.

Une fonction getRandomWord

Voici la fonction à compléter :

def getRandomWord(wordList):
    """Cette fonction renvoie un mot choisi au hasard dans la liste `wordList`."""
    # à compléter

Une fonction displayBoard

On va écrire une fonction displayBoard qui affichera l'état du jeu.

def displayBoard(HANGPICS, missedLetters, correctLetters, secretWord):
    """ Cette fonction a pour arguments :
    - `HANGPICS` : la liste des dessins du pendu
    - `missedLetters` : les lettres manquées par le joueur
    - `correctLetters` : les lettres trouvées par le joueur
    - `secretWord` : le mot à deviner
    Elle affiche l'état du jeu."""
    # à compléter

Une fonction getGuess

Cette fonction est chargée de demander à l'utilisateur de deviner une lettre. Elle doit vérifier que la lettre entrée est valide (une seule lettre, pas déjà devinée, etc.) et renvoyer cette lettre.

def getGuess(alreadyGuessed):
    """Cette fonction demande à l'utilisateur de deviner une lettre.
    Elle prend en argument `alreadyGuessed`, qui est une liste des lettres déjà devinées.
    Elle renvoie la lettre devinée."""
    # à compléter

Une fonction playAgain

Cette petite fonction demande à l'utilisateur s'il veut rejouer ou non. Elle renvoie True si l'utilisateur veut rejouer, False sinon.

def playAgain():
    """Cette fonction demande à l'utilisateur s'il veut rejouer.
    Elle renvoie True si l'utilisateur veut rejouer, False sinon."""
    # à compléter

Le programme principal

On peut maintenant écrire le programme principal qui va utiliser les fonctions précédentes pour faire tourner le jeu. Voici un squelette de code :

import random

#### ici la déclarations des variables HANGPICS et WORDS 
#### Ainsi ques les fonctions précédentes

# Début du programme principal
print('H A N G M A N')

while True:
    # à compléter !!!

La correction

à venir