Author: Adam Y.

Tutoriels

Formater facilement et rapidement un texte sur Word

Que ce soit pour un devoir ou juste pour votre plaisir d’écrivain, le logiciel de traitement de texte Word est bien souvent l’outil privilégié pour consigner ses mots. Mais on a beau s’en servir souvent, on ne prend pas forcément le temps de formater correctement et proprement ce que l’on rédige. Dans ce tutoriel, en plus d’explorer quelques fonctionnalités intéressantes que Word propose, je vous montrerai une manière simple et rapide de formater n’importe quel texte afin de le rendre plus esthétique. Finis les devoirs tapés à l’arrache et au visuel peu attrayant !


Déroulé du tutoriel

  1. La police
  2. L’interligne
  3. Les alinéas
  4. L’alignement
  5. Les marges
  6. Les titres
  7. L’en-tête et le pied de page
  8. Un exemple

1. La police

La police d’un texte est le paramètre le plus crucial dans sa lisibilité. De plus, elle détermine la place qu’il prend sur le document. Plus la police est grande, plus le texte est volumineux (bien entendu).

a) Le type

Comme la majorité des gens le savent, il suffit de cliquer sur la liste déroulante qui contient les types de polices dans l’onglet Accueil afin de modifier l’apparence du texte. Ici vous est proposé un large panel de polices, dont les plus utilisées comme Calibri, Arial ou encore Times New Roman.

Si une police en particulier n’est pas requise par votre professeur ou autre, il serait intéressant de s’aventurer un peu. En se rendant dans l’onglet Conception et en cliquant sur la liste déroulante Thèmes, vous pourrez choisir un thème à appliquer à votre document qui réglera le type et la couleur de votre police.

Cette méthode peut être conseillée si votre document contient beaucoup de texte afin de pouvoir le modifier entièrement en un clic. D’autre part, nous verrons qu’elle aura une autre utilité dans la partie 6 : « Les titres ».

Conseil : Choisissez un thème qui correspond à votre texte. Un devoir à rendre ? Un passage d’une œuvre littéraire ? Il ne tient qu’à vous d’expérimenter et de créer vos préférences. Si, bien entendu, vous ne trouvez pas votre bonheur, vous pouvez rester avec le thème « Office », celui de base.

b) La taille

La manière la plus simple de modifier la taille de votre police et de cliquer sur la liste déroulante juste à droite de celle qui contient les types de polices dans l’onglet Accueil. Vous pouvez choisir la taille qui vous convient le mieux, ou en taper une.

Conseil : La taille de votre police différera en fonction du texte que vous écrivez. Je trouve qu’il est plus esthétique de faire rentrer un texte sur une seule page s’il est court et de ne pas le laisser dépasser de quelques lignes sur une autre. Si vous rédigez un texte qui sera lu à voix haute, je vous conseille de régler la taille de la police à 16 et de faire un grand interligne (prochaine partie).


2. L’interligne

La lisibilité de vos lignes ainsi que de votre texte entier est également influencée par la taille de votre interligne.

a) Les paragraphes

Afin de changer l’espacement entre les paragraphes, vous avez deux possibilités :

  • Se rendre dans l’onglet Mise en page et remplacez le « 8 » dans la case du bas de la section Espacement par la taille que vous désirez. Cette action modifiera le texte surligné par le curseur de votre souris (surligner l’entièreté du document : ctrl + a) ;
  • Se rendre dans l’onglet Accueil et cliquer sur la flèche à droite du mot « Paragraphe ». Une fenêtre devrait s’ouvrir. Dans la section Espacement, remplacez le « 8 » par la taille désirée. Cette action modifiera également le texte surligné par le curseur de votre souris.

Conseil : Si vous rédigez un texte construit, que ce soit une dissertation en français ou une nouvelle, je vous conseille de régler l’espacement des paragraphes à 0. De cette façon, vos paragraphes seront collés et votre texte ne semblera pas fragmenté.

b) Les lignes

Afin de changer l’interligne, vous avez deux possibilités :

  • Choisir la taille de l’espacement depuis l’onglet Accueil avec la liste déroulante prévue. Cette action modifiera le texte surligné par le curseur de votre souris ;
  • Se rendre dans l’onglet Accueil et cliquer sur la flèche à droite du mot « Paragraphe ». Une fenêtre devrait s’ouvrir. Sélectionnez dans la liste déroulante Interligne l’option « Multiple », puis entrez dans la case juste à droite la taille désirée. Cette action modifiera également le texte surligné par le curseur de votre souris.

Conseil : La taille de votre interligne devrait correspondre au type de texte que vous rédigez. Comme je l’ai dit dans la partie précédente, un texte destiné à être lu à voix haute devrait comporter un interligne assez important afin que les lignes soient bien différenciables. Pour ce cas de figure, une taille de 1,5, selon moi, conviendrait le mieux.


3. Les alinéas

Qu’ils soient manuscrits ou tapés, les alinéas permettent de différencier les paragraphes d’un texte et à donner à ce dernier une forme intéressante. Ils sont tapés grâce à la touche Tab ↹.

Comme pour l’interligne, afin de régler la taille des alinéas, vous devez vous rendre dans l’onglet Accueil et cliquer sur la flèche à droite du mot « Paragraphe ». Ensuite, dans la section Retrait, choisissez l’option « Première ligne » de la liste déroulante Spécial, puis réglez la taille désirée dans la case juste à droite. Cette action modifiera le texte surligné par le curseur de votre souris.

Conseil : Réglez la taille des alinéas à 0,5 cm pour un texte littéraire et à 1 cm pour un devoir. Je pense qu’il vaut mieux privilégier des alinéas petits car, lorsqu’ils sont trop larges, le texte semble morcelé.


4. L’alignement

La forme que prend votre texte est en grande partie décidée par l’alignement pour lequel vous optez.

Vous avez deux façons de modifier l’alignement de votre texte :

  • Dans l’onglet Accueil, cliquez sur l’une des quatre propositions dans la section Paragraphe.
  • Dans l’onglet Accueil, cliquez sur la flèche à droite du mot « Paragraphe ». Dans la fenêtre ouverte, faites votre choix dans la liste déroulante Alignement.

Conseil : Optez pour l’alignement « Justifié » si vous pouvez étant donné qu’il équilibre votre texte sur la largeur de la page et le rend davantage homogène. Un problème peut tout de même survenir : les espaces à l’intérieur de certaines lignes peuvent devenir très larges pour que la longueur soit respectée. Dans ce cas, coupez le premier mot de la ligne suivante afin que sa première moitié se retrouve sur la ligne à régler.


5. Les marges

Les marges de votre texte définissent la place occupée par vos mots sur la page et le vide laissé pour les doigts du lecteur.

Afin de modifier les marges, rendez-vous dans l’onglet Mise en page et cliquez sur Marges. De là, vous pouvez choisir dans la liste déroulante le type de marges que vous préférez.

Vous pouvez également créer vos propres marges en cliquant sur Marges personnalisées. Une fenêtre devrait s’ouvrir. Dans la section Marges, entrez les paramètres désirés.

Ou sinon, vous pouvez vous rendre dans l’onglet Affichage et, dans la section Afficher, cochez Règle. Cette manipulation placera une « règle » juste en dessous du ruban grâce à laquelle vous pourrez modifier manuellement les marges du texte surligné par votre souris en bougeant les curseurs blancs.

Conseil : Privilégiez de petites marges afin d’utiliser moins de papier, d’avoir une taille de police plus volumineuse et de ne pas avoir trop de vide sur la page. En revanche, lorsque vous rédigez un texte qui sera lu à voix haute, peut-être pour un oral, il pourrait être intéressant de choisir les marges moyennes afin de laisser davantage de place pour tenir la feuille entre vos doigts.


6. Les titres

Afin que la structure de votre texte soit claire et saute aux yeux, il est fondamental que vos titres et sous-titres se détachent du corps du texte.

a) La manière simple

Selon la logique, un titre doit être plus large que le corps du texte. La méthode la plus simple pour créer cette différence de taille serait de modifier directement le titre en l’agrandissant (cf. la partie 1 : « La police », section b : « La taille »).

Mais en plus d’agrandir le titre, vous pouvez l’agrémenter grâce à l’onglet Accueil. Il est possible de :

  • Le souligner ;
  • L’encadrer ;
  • Ou lui mettre un fond.

Conseil : Centrez vos titres et sous-titres afin qu’ils se démarquent sur la page (cf. la partie 4 : « L’alignement »).

b) La manière plus intéressante

Dans l’onglet Accueil, la liste déroulante Styles permet de formater le texte surligné par votre souris et lui donner une place dans la hiérarchie de vos titres. Plus simplement : il peut attribuer le rôle de « Titre », « Sous-titre » ou « Normal » (corps du texte) à certains paragraphes.

Pour appliquer un style, surlignez votre titre avec le curseur de votre souris et cliquez sur « Titre 1 ».

Si vous avez suivi le conseil que j’ai donné dans la partie 1 : « La police », section a : « Le type », alors il est probable qu’un thème de l’onglet Conception soit appliqué à votre document. Si c’est le cas, alors votre titre aura une couleur et police en accord avec le reste du corps du texte. Chaque thème a un style de titre qui lui est propre.

Cette manière de formater un titre a un avantage : elle place le titre dans le Volet de navigation, accessible en se rendant dans l’onglet Affichage et cochant la case Volet de navigation.

Dans ce volet, allez dans la section Titres, et vous pourrez voir une liste de tous les titres de votre document. En cliquant sur l’un d’eux, la page montera ou descendra jusqu’à lui. Ainsi, en plus d’avoir une table des matières pour votre document (seulement visible s’il est lu numériquement), vous pouvez passer rapidement de partie en partie sans perdre de temps à faire défiler les pages. Si votre document comporte beaucoup de texte, cela pourrait certainement vous faciliter la tâche.

Conseil : Évidemment, si l’aspect de votre titre ne vous convient pas, vous pouvez toujours le modifier en lui laissant le style « Titre 1 ». Cela ne le retirera pas du Volet de navigation. Sinon, vous pouvez inventer vous-même votre propre style en cliquant sur Créer un style. Depuis la fenêtre ouverte, allez dans Modifier… et appliquez au texte les paramètres souhaités.


7. L’en-tête et le pied de page

L’en-tête et le pied de page, bien que pas forcément nécessaires, peuvent être un bon ajout à votre document.

a) L’en-tête

Afin de modifier l’en-tête de votre document, vous n’avez qu’à double-cliquer sur le haut de n’importe quelle page, à environ 1 cm du bord. Si vous n’y parvenez pas, vous pouvez également vous rendre dans l’onglet Insertion, cliquer sur la liste déroulante En-tête et choisir l’une des options.

Lorsque vous avez rempli l’en-tête, il vous suffit de double-cliquer en dehors afin de sortir de ce dernier, ou de cliquer sur Fermer l’en-tête et le pied de page dans la section Fermeture.

Désormais, cet en-tête se trouvera en haut de chaque page de votre document. Si vous souhaitez le changer pour une section en particulier, dans ce cas, rendez-vous dans l’onglet Mise en page, et, dans la liste déroulante Saut de page, choisissez Page suivante. Ensuite, ouvrez l’en-tête de la page apparue et, dans la section Navigation qui s’est affichée, cliquez sur Lier au précédent afin de désactiver cette fonctionnalité. Ainsi, vous pourrez modifier l’en-tête sans affecter celui de la page d’avant.

Conseil : Un en-tête peut servir à placer votre nom, une date, la problématique ou le titre d’une section sur chaque page. Si votre écrit est long, il pourrait être intéressant d’user de cette fonctionnalité.

b) Le pied de page

Modifier le pied de page se fait quasiment de la même façon que pour l’en-tête. Vous pouvez soit double-cliquer sur le bas de n’importe quelle page à environ 1 cm du bord, soit vous rendre dans l’onglet Insertion, cliquer sur la liste déroulante Pied de page et choisir l’une des options.

Et, comme pour l’en-tête, il vous suffit de double-cliquer en dehors du pied de page afin d’en sortir ou de cliquer sur Fermer l’en-tête et le pied de page. En suivant cette logique, changer le pied de page pour une section de votre document se fait de la même manière que pour l’en-tête (cf. section a).

Si vous souhaitez avoir le numéro de la page affiché dans le pied de page, rendez-vous dans l’onglet Insertion, cliquez sur la liste déroulante Numéro de page et choisir Bas de page. Enfin, optez pour l’option désirée (« Numéro normal 2 » est, selon moi, la meilleure).

Conseil : Hormis le numéro de page, vous pouvez mettre en pied de page le titre de votre document ainsi que le nom de son auteur (logiquement, vous).


8. Un exemple

En exemple visuel, nous modifierons ce texte qui n’est pas formaté en appliquant les conseils donnés dans ce tutoriel.

Version originale VS Version formatée

(Début du chapitre 1 de Une Vie, de Maupassant)

Projets

Une partie de Blackjack en Python

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