Ça y est, c’est fait… Je viens de terminer mon programme du jeu de roulette en Python orienté objet ! Et je peux vous dire que je suis vraiment contente d’y être arrivée… C'était un vrai défi, et je suis ravie du chemin parcouru et des compétences que j'ai acquises tout au long de ce projet. Établir les règles du jeu, comprendre les enjeux, et voir le programme fonctionner comme prévu, c'est une satisfaction énorme pour moi. Alors, laissez-moi vous plonger dans les détails de cette aventure passionnante ! 😀
En détail, ça donne quoi ?
J’ai donc créé deux objets :
– l’objet « joueur » qui est défini par son pseudo, son porte-monnaie (l’argent qu’il a au départ), le numéro sur lequel il mise et la somme qu’il mise sur ce numéro. Je voulais que l'expérience de jeu soit la plus fluide possible, c'est pourquoi chaque détail compte dans le développement de cet objet !
– l’objet « jeu » qui est défini par un numéro gagnant et un calcul des gains. Cela permet de séparer clairement la logique du jeu de la gestion des joueurs, ce qui me semble essentiel pour maintenir un code propre et efficace.
Pour simplifier la visualisation de ces objets, j’ai créé 2 fichiers distincts enregistrés dans le même dossier que le fichier avec mon programme final. Cela permet d’appeler plus facilement ces fichiers et de garder l’organisation de mon projet bien structurée, ce qui est crucial, surtout lorsque le programme commence à se complexifier.
L’objet « Joueur »
Pour chaque caractéristique de mon objet « Joueur », j’ai défini une fonction (ou méthode) qui sera utilisée dans le programme final. Une manière de rendre le code plus modulaire et réutilisable.
Je me suis servi du code que j’avais déjà créé lors de mon premier programme : j’en ai extrait les éléments nécessaires et les ai améliorés pour un meilleur fonctionnement du programme. Cela m’a pris du temps, mais le résultat en valait vraiment la peine. J'ai appris à faire des choix judicieux dans l'écriture de mon code, et ça fait toute la différence.
Voici le code de mon objet « Joueur » :
class Joueur: """Classe définissant un joueur de roulette caractérisé par : - son pseudo ; - son porte monnaie ; - un numéro misé - une somme misée """ def __init__(self, pseudo, porte_monnaie, numero_mise, somme_misee): """Constructeur de notre classe""" self.pseudo = pseudo self.porte_monnaie = porte_monnaie self.numero_mise = numero_mise self.somme_misee = somme_misee def nom_joueur(self, pseudo): """Méthode permettant de vérifier que le nom du joueur n'est pas un chiffre et de l'afficher """ NomCorrect = False while NomCorrect == False : self.pseudo = input("Quel est votre nom ?") #self.pseudo = 'Anonyme' if len(self.pseudo) == 0 else self.pseudo try: int(self.pseudo) != False except ValueError: print("Bienvenue {} sur la table de la Roulette du Zcasino !".format(self.pseudo)) NomCorrect = True else : print("Il y a une erreur, êtes vous certain de votre frappe ?") def argent_joueur(self, porte_monnaie): """Méthode permettant de vérifier que le joueur a de l'argent pour jouer""" Argent = False while Argent == False : self.porte_monnaie = input("\nAvec quelle somme d'argent souhaitez vous jouer ? ") try: int(self.porte_monnaie) != False except ValueError: print("Il y a une erreur, êtes vous certain de votre frappe ?") else : self.porte_monnaie = int(self.porte_monnaie) if self.porte_monnaie < 1 : print("Vous ne pouvez pas jouer sans argent !") else : Argent = True def num_joueur(self, numero_mise): """Méthode permettant de vérifier que le joueur a bien misé sur un numéro de la roulette""" Numero = False while Numero == False : self.numero_mise = input("\nSur quel numéro souhaitez vous miser (entre 0 et 49) ? : ") try: int(self.numero_mise) != False except ValueError: print("Il y a une erreur, êtes vous certain de votre frappe ?") else : self.numero_mise = int(self.numero_mise) if self.numero_mise < 0 or self.numero_mise > 49: print("Le numéro choisi n'existe pas, veuillez en choisir un autre !") else : Numero = True def mise_joueur(self, somme_misee): """ Methode permettant de vérifier que le joueur mise l'argent qu'il a dans son porte monnaie """ Mise = False while Mise == False : self.somme_misee = input("\nQuelle somme souhaitez vous miser sur ce numéro ? : ") try: int(self.somme_misee) != False except ValueError : print("Etes vous certain de votre frappe ?") else : self.somme_misee = int(self.somme_misee) if self.somme_misee < 0: print("Vous ne pouvez pas miser un nombre négatif !") elif self.somme_misee > self.porte_monnaie: print("Vous n'avez pas assez d'argent !") else : Mise = True L’objet « Jeu »
Cet objet est plus simple, car il ne contient qu’une seule fonction : celle du calcul des gains. Je voulais que l'interaction avec le jeu soit fluide et intuitive.
Il y a une petite particularité importante à prendre en compte : seule la variable « gain » est associée à l’objet. Lors de la rédaction de la fonction de l’objet, il n’y aura donc que cette variable qui sera nommée avec « self.~ ». Cela permet de garder les choses claires et de bien suivre le flux de données au sein de notre jeu.
Voici le code de mon objet « Jeu »
class Jeu: """Classe définissant le jeu de la roulette caractérisé par : - un numéro gagnant ; - un gain rapporté """ def __init__(self, gagne, gain): """Constructeur de notre classe""" self.gagne = gagne self.gain = gain import random def num_gagnant(self, gagne): """Méthode permettant de selectionner le numéro gagnant """ self.gagne = random.randrange(50) print("Le numéro gagnant est le numéro ", self.gagne) import math def gain_partie(self, gagne, somme_misee, numero_mise, gain): """Méthode permettant de déterminer le gain du joueur en fonction du numéro gagnant """ import math if gagne != numero_mise : if (self.gagne %2 == 0 and numero_mise %2 == 0) or (gagne %2 != 0 and numero_mise %2 != 0): self.gain = math.ceil(somme_misee * 0.5) print("\n Vous avez misé sur la bonne couleur, vous gagnez {} $".format(self.gain)) else: print("\n Loupé, Vous venez de perdre votre mise !") self.gain = -somme_misee else: self.gain = 3 * somme_misee print("\n Votre gain est de 3 fois votre mise, soit {} $".format(self.gain)) Le programme final
J’ai ensuite remplacé dans mon programme initial tous les morceaux mis dans mes objets par l’appel des objets eux-mêmes. Cela a été une étape cruciale et parfois délicate, car un remplacement brut ne marche pas… 😉
Déjà, il faut bien penser à importer les 2 fichiers objets.
import ZCasino_jeu import ZCasino_joueur
Ensuite, l’appel des objets et de ses fonctions doit être fait correctement. J’ai commencé par créer les variables et je les ai mises nulles au départ. Puis j’ai créé le « joueur1 » auquel j’ai attribué mon objet « Joueur » (récupéré depuis mon fichier). L'assignation des méthodes a été une étape clé, une étape où j'ai dû faire preuve de rigueur et d'organisation.
# appel de variables 'nulles' pseudo = 0 porte_monnaie = 0 numero_mise = 0 somme_misee = 0 # description du joueur joueur1 = ZCasino_joueur.Joueur(pseudo, porte_monnaie, numero_mise, somme_misee)
Puis j’ai appelé les différentes fonctions du joueur. Chaque méthode était conçue pour être intuitive et engageante pour l'utilisateur, un véritable moteur de jeu qui permet au joueur de s'impliquer pleinement dans l'expérience. Il ne faut pas oublier d’attribuer les fonctions directement au « joueur1 » ! 😉
pseudo = joueur1.nom_joueur(pseudo) porte_monnaie = joueur1.argent_joueur(porte_monnaie) # ... numero_mise = joueur1.num_joueur(numero_mise) # ... somme_misee = joueur1.mise_joueur(somme_misee)
Lors du calcul des gains, j’ai ensuite créé la variable « gain » nulle pour pouvoir créer le système de calcul en appelant mon objet « Jeu » (via le fichier !). C'était un instant de tension, mais aussi d'excitation, car chaque tour de jeu apporte son lot de surprises !
# gains gain = 0 jeu = ZCasino_jeu.Jeu(gagne, gain) gain = jeu.gain_partie(gagne, joueur1.somme_misee, joueur1.numero_mise, gain)
Il reste ensuite à mettre à jour le porte-monnaie du « joueur1 ». C'est dans ce moment précis que l'on réalise à quel point chaque mise, chaque numéro choisi, peut avoir un impact !
joueur1.porte_monnaie = joueur1.porte_monnaie + jeu.gain print("Il vous reste donc {} $ pour continuer de jouer.".format(joueur1.porte_monnaie)) Et voila le programme est fait ! 😉 Avec un bon mélange de code et de stratégie, il est prêt à offrir des heures de divertissement aux passionnés de roulette.
Le voici complet :
import os import random import math import ZCasino_jeu import ZCasino_joueur # ****** programme du jeu de la roulette ********** print("Bienvenue au ZCasino, voici le jeu de la Roulette !") # appel de variables 'nulles' pseudo = 0 porte_monnaie = 0 numero_mise = 0 somme_misee = 0 # description du joueur joueur1 = ZCasino_joueur.Joueur(pseudo, porte_monnaie, numero_mise, somme_misee) pseudo = joueur1.nom_joueur(pseudo) porte_monnaie = joueur1.argent_joueur(porte_monnaie) # début du jeu j=1 while j != 0 : # numéro choisi par le joueur numero_mise = joueur1.num_joueur(numero_mise) # choisir sa mise somme_misee = joueur1.mise_joueur(somme_misee) print("\n Votre mise est de {} $ sur le numéro {} \n".format(joueur1.somme_misee, joueur1.numero_mise)) # lance la roulette print("A vos jeux... La roulette est lancée... \n") gagne=random.randrange(50) print("Le numéro gagnant est le numéro ", gagne) # gains gain = 0 jeu = ZCasino_jeu.Jeu(gagne, gain) gain = jeu.gain_partie(gagne, joueur1.somme_misee, joueur1.numero_mise, gain) # argent restant au joueur joueur1.porte_monnaie = joueur1.porte_monnaie + jeu.gain print("Il vous reste donc {} $ pour continuer de jouer.".format(joueur1.porte_monnaie)) # possibilité de rejouer ou non if joueur1.porte_monnaie == 0: print("\nVous n'avez plus d'argent ! Au revoir et à bientôt au ZCasino ") j=0 else: r=input(" Voulez vous rejouer ? (O / N) ") if r == "O" or r == "o" : j=1 else: print("Au revoir et à bientôt au ZCasino ") j=0 os.system("pause") # met en pause le système Windows Pour conclure
Voici une citation qui correspond tout à fait à mon état d’esprit après ma réussite. La satisfaction d'avoir créé un programme qui fonctionne comme prévu est inégalable !
Car oui, je suis fière d’avoir réussi cette étape ! 🙂 Cette aventure m'a vraiment appris que la persévérance et la passion pour le code sont les clés du succès.
- Étiquettes Projet, Programmation, Jeu, Logiciel, Innovation