Une partie de Blackjack en Python

Projets

Les jeux d’argent ont beau être peu recommandables, il n’empêche qu’ils restent assez divertissants ; et afin de pouvoir y participer depuis chez soi, sans la moindre répercussion sur son compte en banque, je vous propose une partie de Blackjack grâce à un script en Python ! Vous pouvez miser de la fausse monnaie à votre guise ou simplement jouer pour le plaisir. Serez-vous capable de battre le croupier à plat de couture ?

Un dilemme vite résolu

Ma première idée pour ce projet était entièrement différente ; et, à vrai dire, j’avais véritablement l’intention d’opter pour elle. Seulement, l’intitulé de ce devoir était « Une programmation fonctionnelle en Python ». Mon plan initial s’est avéré très peu adapté à cette problématique ; par conséquent, j’ai préféré me rabattre sur mon second choix : le jeu du Blackjack.

De toute manière, mon idée de base était un tantinet trop ambitieuse pour le type de projet qui était à réaliser : je ne regrette pas ma décision de la changer.

Quelques recherches avant de débuter

Je ne pouvais guère me lancer dans l’écriture de mon script avant d’être certain de connaître les règles du Blackjack. Quelques recherches en ligne m’ont permis rapidement de déterminer les points importants à intégrer :

Les tours :

Le joueur commence. Il débute son tour en tirant deux cartes dont les points constituent son score de base. Ensuite, il a le choix de piocher ou non une nouvelle carte. S’il décide de le faire, les points de la carte sont ajoutés à son score ; sinon, il termine son tour. Son but est d’obtenir le score le plus élevé possible sans jamais dépasser vingt-et-un. Si c’est le cas, son tour s’arrête directement.

Ensuite, c’est au croupier de jouer. Dans un véritable casino, ses règles diffèrent légèrement de celles du joueur ; mais par souci de simplicité, j’ai préféré lui donner les mêmes. Son but est d’obtenir un score supérieur à celui du joueur, ou, au moins, de faire égalité.

Lorsque les deux tours touchent à leur fin, on compte les points. Celui qui en possède le plus sans dépasser vingt-et-un est déclaré vainqueur. Il est possible de faire égalité.

Les points :

Chaque carte possède son propre nombre de points :
– de deux à neuf : autant de points que le nombre affiché sur la carte.
– de dix à roi : 10 points.
– As : 1 ou 11 points (au choix du joueur).

Les mises :

Le joueur mise en début de partie une somme ne pouvant dépasser un certain montant. Ce dernier différant de casino en casino, je l’ai réglé à cent-cinquante euros.

Dans un véritable casino, le joueur a la possibilité de doubler sa mise , ou bien d’abandonner et d’en perdre la moitié, en pleine partie ; toutefois, j’ai pris la liberté de ne pas intégrer cette fonctionnalité afin de ne pas compliquer le jeu.

Si le joueur gagne, il récupère le double de sa mise ; en revanche, s’il perd, il ne la recouvre pas. En cas d’égalité, rien ne se passe.

J’ai consigné toutes ces règles dans mon script, affichées au gré du joueur.

Les premiers tests

Je n’ai pas voulu plonger tête première dans l’écriture de mon code sans avant tout faire quelques essais.

Je n’ai intégré que trois cartes au départ : l’as, le deux et le trois, respectivement à un, deux et trois points.

paquet = ("as","deux","trois")
points = (1, 2, 3)
score_joueur = 0

En créant deux n-uplets et en faisant correspondre le nom des cartes avec leur nombre de points, je pouvais aisément créer un système de pioche grâce au module random et donner le nom et les points de la carte tirée.

carte = randint(0,2) # piochage d'une carte au hasard
print("Votre première carte est un", paquet[carte])
score_joueur += points[carte] # points de la carte ajoutés au score du joueur

carte = randint(0,2)
print("Votre seconde carte est un", paquet[carte])
score_joueur += points[carte]

print("Votre score de base est de", score_joueur)

Lorsque la variable « carte » est égale à 0, par exemple, elle prend le premier item du n-uplet « paquet » et « points » qui correspondent respectivement à « as » et « 1 ». En revanche, si, pour la seconde carte, la variable « carte » vaut 2, elle prend le troisième item des deux n-uplets qui est « trois » et « 3 ». Une autre variable « score_joueur » récupère les points gagnés afin de constituer le score.

Dans cette situation, le script afficherait :

J’ai ainsi codé le début du tour du joueur.

Afin de respecter l’intitulé du projet (« Une programmation fonctionnelle en Python »), j’ai placé cette partie de code dans une fonction que j’ai nommée « base() ». J’ai également rendu la variable « score_joueur » globale de sorte qu’elle soit utilisable dans toutes les fonctions.

paquet = ("as","deux","trois")
points = (1, 2, 3)
score_joueur = [0]

def base():
    carte = randint(0,2) # piochage d'une carte au hasard
    print("Votre première carte est un", paquet[carte])
    score_joueur[0] += points[carte] # points de la carte ajoutés au score du joueur
    carte = randint(0,2)
    print("Votre seconde carte est un", paquet[carte])
    score_joueur[0] += points[carte]
    print("Votre score de base est de", score_joueur[0])
    
base()

Et, à partir de cette base, j’ai codé la partie « joueur » du jeu.

La partie « joueur »

Puisque le système qui met en place le score de base était déjà intégré, je me suis ensuite attelé au codage du reste du tour.

Selon les règles du Blackjack, le joueur décide s’il souhaite piocher une nouvelle carte ou non tant que son score est inférieur à vingt-et-un. Subséquemment, j’ai repris le code de la fonction « base() » dans une nouvelle fonction nommée « choix_joueur() » et ajouté une condition pour qu’il soit exécuté :

def choix_joueur():
    while score_joueur[0] < 21: # tant que le score du joueur est strictement inférieur à 21, il peut continuer de piocher
        ch = input("[Voulez-vous piocher ?] " )
        if ch == "o": # si le joueur continue de piocher
            carte = randint(0,2) # piochage d'une carte au hasard
            print("Vous piochez un", paquet[carte])
            score_joueur[0] += points[carte] # points de la carte ajoutés au score du joueur
            print("Votre score est de", score_joueur[0], "\n")
        elif ch == "n": # si le joueur cesse de piocher
            print("Vous décidez de vous arrêter.")
            break

Ce script peut, par exemple, afficher :

Afin que cette fonction se lance, je l’ai appelée à la fin de « base() » :

def base():
    carte = randint(0,2) # piochage d'une carte au hasard
    print("Votre première carte est un", paquet[carte])
    score_joueur[0] += points[carte] # points de la carte ajoutés au score du joueur
    carte = randint(0,2)
    print("Votre seconde carte est un", paquet[carte])
    score_joueur[0] += points[carte]
    print("Votre score de base est de", score_joueur[0])
    score_joueur() # suite du tour

Si le joueur dépasse le score de vingt-et-un, il perd automatiquement. J’ai, de ce fait, défini une fonction « defaite() » qui est appelée si le joueur va trop loin :

def choix_joueur():
    while score_joueur[0] < 21: # tant que le score du joueur est strictement inférieur à 21, il peut continuer de piocher
        # [...]
    if score_joueur[0] > 21:
    	defaite()

def defaite(): # lorsque le joueur perd
    print("Vous avez perdu...")

En revanche, si le joueur tombe pile sur vingt-et-un, il ne gagne pas automatiquement puisque le croupier pourrait faire égalité ; à la place, le jeu passe directement au tour du croupier et ne laisse pas le choix de tirer ou non une nouvelle carte. Étant donné que cesser de piocher et atteindre le score de vingt-et-un ont les mêmes conséquences, j’ai regroupé ces deux conditions en une seule :

    if score_joueur[0] > 21:
    	defaite()
    else:
        choix_ordi()

(La fonction « choix_ordi() » sera détaillée dans la prochaine partie : elle correspond au tour du croupier.)

Avec le codage du tour du joueur terminé, je pouvais désormais m’affairer à celui du croupier.

La partie « croupier »

Une fois la partie « joueur » créée, il ne suffisait que de recopier son code et de lui retirer son interactivité afin de programmer la partie « croupier ».

Ainsi, j’ai définie la fonction « choix_ordi » (montrée dans la partie précédente) et ajouté une nouvelle variable globale que j’ai nommée « score_ordi ». Le croupier continue de piocher tant qu’il n’a pas dépassé le score du joueur.

paquet = ("as","deux","trois")
points = (1, 2, 3)
score_joueur = [0]
score_ordi = [0]

def base():
	#[...]

def choix_joueur():
	#[...]

def choix_ordi():
    carte = randint(0,2) # piochage d'une carte au hasard
    print("La première carte du croupier est", paquet[carte])
    score_ordi[0] += points[carte] # points de la carte ajoutés au score du croupier
    carte = randint(0,2)
    print("La seconde carte du croupier est", paquet[carte])
    score_ordi[0] += points[carte]
    print("Le score de base du croupier est de", score_ordi[0], "\n")
    while score_ordi[0] < score_joueur[0]: # le croupier ne cessera pas de piocher tant que son score est inférieur à celui du joueur
        carte = randint(0,2)
        print("Le croupier pioche", paquet[carte])
        score_ordi[0] += points[carte]
        print("Le score du croupier est de", score_ordi[0], "\n")
    if score_ordi[0] > 21: # si le score du croupier dépasse 21, le joueur gagne automatiquement
      	reussite()
    else:
        print("Le croupier décide de s'arrêter.")
        defaite()

def defaite(): # lorsque le joueur perd
    print("Vous avez perdu...")

def reussite(): # lorsque le joueur gagne
  	print("Vous avez gagné !")

J’ai également créé la fonction « reussite() » qui est appelée lorsque le joueur gagne la partie.

La partie « croupier » m’a amené à réfléchir à l’intelligence artificielle de mon ordi. Oui, il est logique qu’il cesse de piocher lorsque son score est supérieur à celui du joueur et qu’il ne le fasse pas avant ; mais s’il tombe pile sur son score ? Devrait-il continuer et peut-être dépasser vingt-et-un où devrait-il s’arrêter ? En prenant en compte le système de mise d’argent, je me suis rendu à l’évidence qu’il valait mieux que, à un certain stage, si les deux scores sont identiques, le croupier ne tente pas sa chance.

J’ai donc complété la boucle while de la fonction afin qu’elle corresponde à mes attentes et est défini une nouvelle fonction : « egalite() ».

def choix_ordi():
    # [...]
    while score_ordi[0] <= score_joueur[0]:
        if score_ordi[0] == score_joueur[0]:
            if score_joueur[0] >= 15:
                break # si le score du croupier est égal à celui du joueur et est supérieur ou égal à 15, il cesse de piocher automatiquement
       # [...]
    if score_ordi[0] > 21:
    	reussite()
    else:
      	print("Le croupier décide de s'arrêter.")
      	if score_ordi[0] > score_joueur[0]:
      		defaite()
      	else:
      		egalite()

def egalite():
  	print("Vous avez fait égalité.")

Désormais, si le croupier fait un score identique à celui du joueur, il arrête de piocher s’il est au minimum à quinze ; sinon, il continue. Mon résonnement est simple : lorsque j’implémenterai le reste des cartes (partie suivante), il y aura plus de chances de dépasser vingt-et-un en piochant une carte à partir de quinze que non. Le croupier ne préfère pas tenter le diable.

Par ailleurs, un problème assez flagrant est visible à l’affichage de ce code, dans la console : tout le texte qui décrit le tour du croupier est imprimé en une fois, sans laisser le temps au joueur de lire.

(Texte imprimé en un coup.)

Le rythme d’affichage sera réglé plus tard, dans la partie « Les finitions ».

Le reste des cartes

Une fois la structure du jeu quasiment terminée (ne manquant que le système de mises et de banque qui sera traité dans la prochaine partie), je me suis décidé à ajouter le reste des cartes.

paquet = ("as","deux","trois","quatre","cinq","six","sept","huit","neuf","dix","valet","dame","roi")
points = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10)

Bien entendu, je ne me suis pas soucié de la couleur de chacune étant donné que seule la valeur importe dans le jeu du Blackjack.

D’autre part, j’ai changé le système de pioche en écrivant :

carte = randint(0,12)

Une fois le paquet entier codé, j’ai constaté un problème avec la carte « dame ». Lorsque cette dernière était piochée, il était affiché :

« Vous piochez un dame ». Quand bien même cette erreur est anodine, j’ai préféré la régler directement. De ce fait, j’ai modifié le n-uplet contenant le nom des cartes en ajoutant le bon article :

paquet = ("un as","un deux","un trois","un quatre","un cinq","un six","un sept","un huit","un neuf","un dix","un valet","une dame","un roi")

Ensuite, j’ai retiré les mots qui compromettaient cette nouvelle organisation :

print("Vous piochez", paquet[carte]) # au lieu de "print("Vous piochez un", paquet[carte])"

Le cas de l’as

Selon les règles du Blackjack, lorsqu’un as est tiré, le joueur peut choisir entre un et onze points. Par souci de fidélité au vrai jeu, j’ai décidé d’intégrer cette fonction. Cela signifiait deux choses : je devais donner la possibilité au joueur de prendre la décision et je devais programmer une intelligence artificielle qui choisirais la meilleure tactique.

Pour la première problématique, j’ai implémenté une condition qui vérifie si un as est tiré ou non. Si c’est le cas, un choix est donné au joueur :

def base():
    carte = randint(0,12)
    print("Votre première carte est", paquet[carte])
    if carte == 0: # si la carte est un as (choix entre 1 et 11 points)
        As = int(input("Préférez-vous qu'elle vaille 1 ou 11 points ? "))
        if As == 1:
            carte = 0
            print()
        elif As == 11:
            carte = 13
            print()
    score_joueur[0] += points[carte]
    carte = randint(0,12)
    print("Votre seconde carte est", paquet[carte])
    if carte == 0:
        As = int(input("Préférez-vous qu'elle vaille 1 ou 11 points ? "))
        if As == 1:
            carte = 0
            print()
        elif As == 11:
            carte = 13
            print()
    score_joueur[0] += points[carte]
    print("Votre score de base est de", score_joueur[0], "\n")
    choix_joueur()

Ici, si la variable « carte » prend la valeur 0, elle correspond au premier item du n-uplet « paquet » qui se trouve être as. Dans ce cas, le script donne le choix au joueur. S’il opte pour un point, on donne à la variable « carte » la valeur 0 ; en revanche, s’il opte pour onze points, on lui donne la valeur 13, soit le douzième item du n-uplet « points ».

Cela nous donne :

On applique ce processus à la fonction « choix_joueur() » :

def choix_joueur():
    while score_joueur[0] < 21:
        ch = input("[Voulez-vous piocher ?] " )
        if ch == "o":
            carte = randint(0,12)
            print("Vous piochez", paquet[carte])
            if carte == 0: # si la carte est un as (choix entre 1 et 11 points)
                As = int(input("Préférez-vous qu'il vaille 1 ou 11 points ? "))
                if As == 1:
                    carte = 0
                    print()
                elif As == 11:
                    carte = 13
                    print()
            score_joueur[0] += points[carte]
            print("Votre score est de", score_joueur[0], "\n")
        elif ch == "n":
            print("Vous décidez de vous arrêter.")
            break
    if score_joueur[0] > 21:
        defaite()
    else:
        choix_ordi()

Dès lors que la partie « joueur » est complétée, je pouvais m’atteler au processus de décision de l’ordi en commençant avec les deux cartes piochées au début de son tour.

Que la première carte piochée vaille un ou onze points, cela n’importe guère. Par conséquent, j’ai décidé de laisser le hasard faire les choses :

def choix_ordi():
    carte = randint(0,12)
    print("La première carte du croupier est", paquet[carte])
    if carte == 0: # si la carte du croupier est un as
        As = randint(1,2) # le croupier choisi au hasard entre 1 et 11 points
        if As == 1:
            print("Le croupier préfère que la carte vaille 1 point.")
            carte = 0
        else:
            print("Le croupier préfère que la carte vaille 11 points.")
            carte = 13        
    score_ordi[0] += points[carte]

Par contre, pour la deuxième carte, le processus est légèrement plus complexe.

Tout d’abord, si la première carte était un as à onze points, il est impératif que le croupier opte pour un point pour sa deuxième carte afin de ne pas dépasser vingt-et-un. Ce cas de figure, quand bien même plutôt rare, reste tout de même important à prendre en compte.

Sinon, il faut vérifier si ajouter onze au score du croupier le fait dépasser celui du joueur. Si c’est le cas, le deuxième as devrait correspondre automatiquement à onze points.

Si aucun de ces deux conditions n’est vraie, le croupier choisit au hasard.

carte = randint(0,12)
    print("La seconde carte du croupier est", paquet[carte])
    if carte == 0:
        if score_ordi[0] + 11 > 21: # si ajouter 11 points au score actuel du croupier le fait dépasser 21, l'as vaut 1 point
            print("Le croupier préfère que la carte vaille 1 point.")
            carte = 0
        elif score_ordi[0] + 11 >= score_joueur[0]: # si ajouter 11 points au score actuel du croupier le fait atteindre le score du jouer, l'as vaut 11 points 
            print("Le croupier préfère que la carte vaille 11 points.")
            carte = 13
        else:
            As = randint(1,2) # sinon, le croupier choisi au hasard entre 1 et 11 points
            if As == 1:
                print("Le croupier préfère que la carte vaille 1 point.")
                carte = 0
            else:
                print("Le croupier préfère que la carte vaille 11 points.")
                carte = 13
    score_ordi[0] += points[carte]

La même logique est appliquée pour le reste du tour.

Maintenant que toutes les cartes sont programmées, le projet ne semble plus très loin de sa fin. Encore quelques efforts !

Le système de mises et de banque

Un jeu d’argent ne serait rien sans l’argent lui-même.

La « banque » correspond à la quantité d’argent détenu par le joueur. Dans le code, elle est représentée par une variable globale :

banque = [300]

Par défaut, elle contient trois-cents euros (ce montant sera expliqué plus tard).

J’ajoute au système de banque la possibilité de miser en début de partie grâce à la fonction « miser() » :

mise = [0]

def miser():
    euro = int(input("Combien d'euros souhaitez-vous miser ? "))
    mise[0] = euro
    print()
    base()

La fonction globale « mise » sert à récupérer le montant versé par le joueur pour ensuite, lorsque la partie touche à sa fin, modifier la banque.

Dans la partie « Quelques recherches avant de débuter », j’ai expliqué que les casinos mettent en place un montant maximum pour les mises. J’ai élevé le mien à cent-cinquante euros. Une condition doit être implémentée dans la fonction afin de respecter ce choix.

def miser():
    while True:
    	euro = int(input("Combien d'euros souhaitez-vous miser ? (150 maximum) "))
    	if euro > 150: # si la mise est supérieure à 150
        	print("Vous devez miser en-dessous de 150 €.\n")
    	else:
        	break
    mise[0] = euro
    print()
    base()

Outre le montant de cent-cinquante euros, la mise du joueur ne peut pas dépasser le contenu de sa banque. Par exemple, si la banque du joueur contient cent euros, il ne peut pas en miser cent-cinquante.

def miser():
    while True:
    	euro = int(input("Combien d'euros souhaitez-vous miser ? (150 maximum) "))
    	if euro > 150: # si la mise est supérieure à 150
        	print("Vous devez miser en-dessous de 150 €.\n")
        elif euro > banque[0]: # si la mise est supérieure au contenu de la banque
        	print("Vous ne pouvez pas miser davantage que vous possédez (Votre banque contient", banque[0], "€)\n")
    	else:
        	break
    mise[0] = euro
    print()
    base()

Enfin, une mise négative ou nulle ne peut être acceptée : elle doit valoir au minimum un euro.

def miser():
    while True:
    	euro = int(input("Combien d'euros souhaitez-vous miser ? (150 maximum) "))
    	if euro > 150: # si la mise est supérieure à 150
        	print("Vous devez miser en-dessous de 150 €.\n")
        elif euro > banque[0]: # si la mise est supérieure au contenu de la banque
        	print("Vous ne pouvez pas miser davantage que vous possédez (Votre banque contient", banque[0], "€)\n")
    	elif euro <= 0: # si la mise vaut 0 ou moins
        	print("Vous devez miser davantage afin de pouvoir participer.\n")
        else:
        	break
    mise[0] = euro
    print()
    base()

La fonction est affichée de cette manière dans la console :

Désormais, il ne reste qu’à programmer les conséquences qui viennent modifier la banque lors d’une réussite ou défaite.

Lors d’une défaite, le joueur perd simplement la mise.

def defaite():
    print("Vous avez perdu...")
    banque[0] -= mise[0] # on soustrait à la banque la mise
    print("Votre banque contient", banque[0], "€") # affichage du contenu de la banque
	nouvelle_partie()

def nouvelle_partie():
    rejouer = input("Désirez-vous refaire une partie ? (\"o\" ou \"n\") ")
    if rejouer == "o": # si le joueur veut refaire une partie, son score ainsi que celui du croupier sont réinitialisés
        score_joueur[0] = 0
        score_ordi[0] = 0
        print()
        miser()
    elif rejouer == "n":
        fin()

def fin(): # lorsque le joueur ne veut pas refaire une partie
    print()
    print("À la prochaine !")

Entre autre, j’ai défini deux autres fonctions : « nouvelle_partie() » qui propose au joueur de rejouer et réinitialise les scores, et « fin() » si le joueur veut finir la partie.

Le processus est similaire pour la fonction « reussite() » :

def reussite():
  	print("Vous avez gagné !")
	banque[0] += 2 * mise[0] # on ajoute à la banque le double de la mise
    print("Votre banque contient", banque[0], "€")
    nouvelle_partie()

Une fois ces fonctionnalités programmées, un problème m’a sauté aux yeux : à quoi sert ce système de banque et de mise si, au final, cela n’a pas de conséquences ? Afin de donner un but précis au jeu, j’ai programmé la possibilité de perdre la partie si le contenu de la banque descend à zéro ou moins, ou de la gagner si le contenu atteint les mille euros.

def defaite():
    print("Vous avez perdu...")
    banque[0] -= mise[0]
    print("Votre banque contient", banque[0], "€")
    if banque[0] <= 0: # si la banque est vide, le joueur perd la partie
        print("Vous ne possédez plus assez d'argent pour pouvoir participer.")
        print("Vous êtes complétement ruiné !")
        rejouer = input("Désirez-vous rejouer ? (\"o\" ou \"n\") ")
        if rejouer == "o": # réinitialisation des paramètres
            banque[0] = 300
            score_joueur[0] = 0
            score_ordi[0] = 0
            print()
            miser()
        elif rejouer == "n":
            fin()
    else:
        nouvelle_partie()

Cette partie de code affiche :

def reussite():
  	print("Vous avez gagné !")
	banque[0] += 2 * mise[0]
    print("Votre banque contient", banque[0], "€")
    nouvelle_partie()
	if banque[0] >= 1000: # si le contenu de la banque atteint les 1000 €, le joueur gagne la partie
    	print("Votre banque contient", banque[0], "€ : vous avez atteint les 1000 € !\n")
    	print("Vous gagnez la partie !")
    	fin()
    else:
      	nouvelle_partie()

Implémenter ces fonctionnalités m’a également fait prend conscience d’une chose : peut-être que le joueur n’aimerait pas mettre de l’argent en jeu et désirerait simplement faire une partie pour le plaisir. De ce fait, je lui ai donné la possibilité de choisir entre deux modes : le mode « libre », sans mises, ou le mode « casino ».

mode = ["libre"]

mode[0] = input("Quel mode de jeu voulez-vous : libre ou casino ? ")

Ce morceau de code sera intégré à la fonction « menu() » dont je parlerai dans la prochaine partie.

Les modifications causées par le choix du mode sont assez nombreuses ; il est conseillé d’aller vérifier le code lui même donné à la fin de l’article.

Les finitions

Je touchait presque la fin de mon projet, seulement quelques bricoles restaient à régler.

Premièrement, il fallait intégrer les règles du Blackjack au début afin d’informer le joueur. Elles sont affichées grâce à la fonction « menu() », la première à être appelée dans le code.

def menu(): # première chose affichée
    print("Bienvenue au jeu du Blackjack !")
    regles = input("Souhaitez-vous lire les règles ? (\"o\" ou \"n\") ")
    if regles == "o": # affichage des règles
        # [...]
    print()
    mode[0] = input("Quel mode de jeu voulez-vous : libre ou casino ? ")
    if mode[0] == "libre":
        base()
    elif mode[0] == "casino": # contenu de la banque donné pour la première mise, inutile après la première partie
        print()
        print("Votre banque contient", banque[0], "€")
        miser()

Cela nous donne :

(L’entièreté des règles est affichée dans le script donné à la fin de cet article.)

Un autre problème à régler était le rythme du jeu : le texte était affiché en une seule fois, rendant l’expérience de jeu bien laborieuse. Grâce au module time et à sa fonction « sleep() », j’ai pu rendre l’affichage plus lent, imitant presque le chargement d’un vrai jeu vidéo !

Le dernière point le plus complexe à régler était l’espacement entre certaines lignes : afin que l’affichage soit cohérent, les sauts à la ligne doivent conserver la même logique. Je vous épargne toutes les modifications faites, hormis une que je trouve particulièrement pratique :

print()
print("------------------------------------\n")
sleep(1)

Cette barre de séparation aide vraiment à discerner les différentes parties du jeu à l’affichage, ce qui permet au joueur de mieux se repérer dans la partie.

Pour terminer, j’ai quelque peu modifié les choix qui sont présentés au fil d’une partie afin que le joueur ne puisse pas entrer n’importe quoi, grâce à une boucle while :

while True: # choix du mode
	mode[0] = input("Quel mode de jeu voulez-vous : libre ou casino ? ")
    if mode[0] != "libre" and mode[0] != "casino":
    	print("Désolé, mais ce n'est pas un choix proposé.\n")
        sleep(2)
    else:
        break

Et enfin, après quelques ajouts esthétiques, le script est enfin achevé !

Conclusion

Malgré la taille du projet et mon niveau peu haut en matière d’écriture de script, coder ce jeu a été plutôt plaisant, et chaque problème rencontré m’a paru comme une énigme à résoudre. Oui, quelquefois, j’ai été frustré par les bugs qui semblaient impossibles à régler ; mais à force de patience et persévérance, je suis parvenu à un script satisfaisant à mon goût ainsi qu’un jeu qui fonctionne !

Le script à télécharger

blackjackTélécharger