Exercice 2 : Développer un mini-jeu 'Devinez le nombre'

Objectif du projet : un jeu interactif de devinettes

Pour ce deuxième projet, nous allons créer un jeu classique et amusant : "Devinez le Nombre". Le principe est simple : l'ordinateur choisit secrètement un nombre entier à l'intérieur d'une plage définie (par exemple, entre 1 et 100). Le joueur doit ensuite essayer de deviner ce nombre. Après chaque proposition du joueur, l'ordinateur lui donne un indice, lui indiquant si le nombre secret est plus grand ou plus petit que sa proposition. Le jeu continue jusqu'à ce que le joueur trouve le nombre secret, et le programme félicite alors le joueur en indiquant le nombre de tentatives qu'il lui a fallu.

Ce projet vous permettra de mettre en pratique et de consolider les compétences suivantes :
- L'utilisation du module random de Python, et plus spécifiquement la fonction random.randint() pour générer un nombre aléatoire.
- L'emploi d'une boucle while pour contrôler le déroulement du jeu et permettre au joueur de faire plusieurs tentatives.
- La gestion des entrées utilisateur avec input() et la conversion de ces entrées en nombres entiers avec int().
- L'utilisation intensive des structures conditionnelles (if, elif, else) pour comparer la proposition du joueur au nombre secret et fournir les indices appropriés.
- Le comptage des tentatives du joueur à l'aide d'une variable compteur.
- L'affichage de messages informatifs et de feedback au joueur.

Ce type de jeu est un excellent moyen d'apprendre à structurer un programme interactif simple et à gérer un état de jeu qui évolue en fonction des actions de l'utilisateur.

Décomposition du problème : les étapes clés du jeu

Structurons la création de notre jeu en étapes logiques pour faciliter le développement :

1. Message de bienvenue et règles du jeu :
- Accueillir le joueur et lui expliquer brièvement le but du jeu et la plage de nombres possibles.
Exemple : print("Bienvenue au jeu 'Devinez le Nombre' !")
print("Je vais penser à un nombre entre 1 et 100. Essayez de le deviner !")

2. Importer le module nécessaire :
- Pour générer un nombre aléatoire, nous aurons besoin du module random.
Exemple : import random

3. Définir la plage et générer le nombre secret :
- Choisir les bornes minimale et maximale pour le nombre secret.
- Utiliser random.randint(min, max) pour que l'ordinateur choisisse un nombre au hasard dans cette plage (bornes incluses).
Exemple :

nombre_minimum = 1
nombre_maximum = 100
nombre_secret = random.randint(nombre_minimum, nombre_maximum)

4. Initialiser les variables du jeu :
- Un compteur pour le nombre de tentatives du joueur, initialisé à 0.
- Une variable booléenne (par exemple, trouve) pour indiquer si le nombre a été trouvé, initialisée à False. Cette variable contrôlera la boucle principale du jeu.
Exemple :

nombre_tentatives = 0
trouve = False

5. Boucle principale du jeu :
- Utiliser une boucle while not trouve: (ou while trouve == False:) pour continuer tant que le joueur n'a pas deviné le nombre.
- A l'intérieur de la boucle :
a. Demander une proposition au joueur : Utiliser input(). Penser à convertir la chaîne en entier avec int(). Il est judicieux d'inclure cette conversion dans un bloc try-except ValueError pour gérer le cas où le joueur entre autre chose qu'un nombre.
b. Incrémenter le compteur de tentatives.
c. Comparer la proposition au nombre secret :
- Si proposition < nombre_secret : afficher "C'est plus !".
- Si proposition > nombre_secret : afficher "C'est moins !".
- Si proposition == nombre_secret : le joueur a gagné ! Mettre trouve à True pour sortir de la boucle, et afficher un message de félicitations incluant le nombre de tentatives.

6. Message de fin de jeu :
- Une fois sorti de la boucle (parce que le nombre a été trouvé), on peut afficher un message final si besoin, bien que le message de félicitations soit souvent suffisant.

Cette structure vous donne une base solide. Vous pourrez ensuite l'améliorer en ajoutant, par exemple, une vérification pour s'assurer que la proposition du joueur est bien dans la plage définie (1-100).

Code source complet et explications détaillées

Passons maintenant à une implémentation complète du jeu "Devinez le Nombre", en suivant la décomposition établie et en intégrant la gestion des erreurs de saisie.

# Projet 2 : Jeu 'Devinez le Nombre' en Python

import random # Module pour la génération de nombres aléatoires

def jeu_devinez_le_nombre():
    """Fonction principale pour le jeu 'Devinez le Nombre'."""
    print("-"*40)
    print("Bienvenue au jeu 'Devinez le Nombre' !")
    print("-"*40)

    nombre_minimum = 1
    nombre_maximum = 100
    nombre_secret = random.randint(nombre_minimum, nombre_maximum)
    
    print(f"J'ai choisi un nombre secret entre {nombre_minimum} et {nombre_maximum}.")
    print("A vous de le deviner...")
    # Pour le débogage, vous pouvez décommenter la ligne suivante :
    # print(f"(Psst... le nombre secret est {nombre_secret})")

    nombre_tentatives = 0
    trouve = False

    while not trouve:
        try:
            proposition_str = input("\nVotre proposition : ")
            proposition = int(proposition_str) # Convertir l'entrée en entier
            nombre_tentatives += 1 # Incrémenter le compteur de tentatives

            # Vérifier si la proposition est dans la plage autorisée
            if proposition < nombre_minimum or proposition > nombre_maximum:
                print(f"Attention ! Veuillez proposer un nombre entre {nombre_minimum} et {nombre_maximum}.")
                continue # Recommence la boucle while sans compter comme une "mauvaise" tentative de devinette

            # Comparer la proposition au nombre secret
            if proposition < nombre_secret:
                print("C'est plus !")
            elif proposition > nombre_secret:
                print("C'est moins !")
            else:
                trouve = True # Le joueur a trouvé !
                print("-"*40)
                print(f"🎉 Bravo ! Vous avez trouvé le nombre secret ({nombre_secret}) ! 🎉")
                print(f"Vous avez réussi en {nombre_tentatives} tentative(s).")
                print("-"*40)

        except ValueError:
            print("Entrée invalide. Veuillez entrer un nombre entier.")
        except Exception as e:
            print(f"Une erreur inattendue est survenue : {e}")
    
    print("Merci d'avoir joué ! Au revoir.")

# Appel de la fonction principale pour démarrer le jeu
if __name__ == "__main__":
    jeu_devinez_le_nombre()

Explications du code :
- import random : Indispensable pour random.randint().
- nombre_minimum, nombre_maximum : Définissent la plage du jeu, facilitant sa modification si besoin.
- nombre_secret = random.randint(...) : Sélectionne le nombre aléatoire que le joueur devra deviner.
- # print(f"(Psst... le nombre secret est {nombre_secret})") : Cette ligne commentée est un exemple classique d'aide au débogage. En la décommentant, vous pouvez voir le nombre secret et tester plus facilement la logique de votre jeu.
- nombre_tentatives = 0 et trouve = False : Initialisation des variables d'état du jeu.
- while not trouve: : La boucle principale qui continue tant que la condition trouve est fausse.
- try...except ValueError: : Gère le cas où l'utilisateur entre quelque chose qui ne peut pas être converti en int (par exemple, du texte).
- proposition < nombre_minimum or proposition > nombre_maximum : Ajout d'une vérification pour s'assurer que le joueur reste dans les limites du jeu. Le continue permet de redemander une saisie sans sortir de la logique principale de devinette.
- if/elif/else : Coeur de la logique du jeu, fournissant les indices "C'est plus !", "C'est moins !", ou déclarant la victoire.
- trouve = True : Lorsque le nombre est trouvé, cette variable est mise à True, ce qui provoquera la sortie de la boucle while à la prochaine évaluation de sa condition.
- if __name__ == "__main__": : Assure que le jeu démarre quand on exécute le script.

Pistes d'amélioration et défis supplémentaires :
1. Limiter le nombre de tentatives : Si le joueur dépasse un certain nombre d'essais, le jeu s'arrête et révèle le nombre secret.
2. Proposer de rejouer : A la fin d'une partie, demander au joueur s'il veut en commencer une nouvelle.
3. Niveaux de difficulté : Permettre au joueur de choisir un niveau de difficulté qui influencerait la plage de nombres (par exemple, 1-50 pour facile, 1-1000 pour difficile).
4. Meilleurs messages : Rendre les messages plus variés ou plus encourageants.
5. Historique des propositions : Afficher les précédentes propositions du joueur pour l'aider à affiner sa stratégie.

Ce projet de jeu est un excellent moyen de s'entraîner avec les boucles, les conditions, et l'interaction utilisateur en Python. Amusez-vous à le coder, à le tester et à l'améliorer selon vos propres idées !