Écrivez du code Python maintenable

Forts de notre expérience, nous souhaitons créer un jeu de cartes pour passer des soirées endiablées avec nos proches... Nous allons créer un jeu de 52 cartes à jouer standard. Le nombre de joueurs pourra être sélectionné, et nous distribuerons une carte à chaque joueur. La carte la plus haute gagne. ♦🃏♣

Tout d’abord, nous commencerons à coder, en apportant des modifications à mesure que nous avancerons. Plus tard, nous développerons davantage certaines parties de l’application. Si nous suivons de bons principes de programmation et le MVC, l’impact de nos changements sera minimal.

Tout au long de cette implémentation, nous nous baserons sur ce projet GitHub, créé pour l’occasion. 😉

Voici les prérequis pour l’application :

Spécifications pour la jouabilité

• Créez un jeu de cartes standard de 52 cartes.

• Entrez des noms de joueurs. Limitez le nombre de joueurs à cinq.

• Battez les cartes.

• Distribuez une carte à chaque joueur (face vers le bas).

• Retournez les cartes de tous les joueurs, montrant quelle carte ils ont.

• Vérifiez quel joueur a la carte de plus haut rang : As > Roi > Reine > Valet > 10… > 2.

• En cas d’égalité, on départage les joueurs grâce à la couleur :

Trèfle > Pique > Cœur > Carreau.

• Montrez le nom et la carte du gagnant.

• Remettez toutes les cartes dans la pile.

• Retournez à l’étape du battage des cartes.

Comment planifier le Modèle ?

Identifions les principaux éléments que les joueurs vont voir, et avec lesquels ils auront des interactions. La façon la plus directe de trouver les objets du modèle est de parcourir les spécifications en cherchant des mots-clés. Ainsi, en regardant la description, vous trouverez le jeu de cartes (une collection de cartes à jouer), les joueurs, le rang des cartes, et la couleur des cartes.

Bien que ce ne soit pas mentionné explicitement, la carte unique pour chaque joueur appartient à une classe main. Cela suit le principe de la responsabilité unique – l’un des principes SOLID que nous allons rencontrer plus tard.

Un joueur est constitué de son nom et de sa main. De la sorte, un éventuel changement de règles concernera probablement le nombre de cartes contenues dans une main, ou un élément relatif à la façon dont les cartes sont manipulées. Vous ne devriez pas avoir à changer le modèle basique d’un joueur si vous jouez à un jeu différent.

Comment implémenter le Modèle ?

Maintenant, vous allez devoir créer des objets Python pour chaque élément du modèle. Créons-les ensemble ! Ouvrez un fichier Python vierge dans votre éditeur, et suivez en regardant les vidéos.

Étape 1 : Générez les cartes à jouer

Voici le lien vers le code.

Nous avons créé :

• un dictionnaire de constantes SUITS (couleurs) listant les couleurs ;

• un dictionnaire de constantes RANKS (rangs) listant les rangs ;

• une classe Card (Carte) ayant un rang et une couleur.

Étape 2 : Générez le jeu de cartes à jouer

Voici le lien vers le code.

Nous avons créé :

• une classe Deck (Jeu) qui contient toutes les cartes à jouer, ainsi que quelques méthodes pour les manipuler (shuffle  pour mélanger les cartes, etdraw_card pour piocher une carte).

Étape 3 : Générez les joueurs

Voici le lien vers le code.

Nous avons créé :

• une classe  Hand  (Main) contenant 0 ou davantage d’objets  Card  ;

• une classe  Player  (Joueur) contenant un nom et une main.

Nous modifierons à nouveau ce modèle plus tard, lorsque nous étudierons les principes SOLID ! Mais d’abord, nous devrons créer la vue et le contrôleur.

En résumé

• Le modèle est constitué des éléments avec lesquels vous avez des interactions. Ceux-ci contiennent les informations sur l’état du système.

• Pour trouver vos objets de modèle, consultez la liste des prérequis.

• Dans notre application, nous avons défini que :

  ○      Le modèle est constitué d’un joueur, d’une main, d’une carte à jouer, d’un jeu, d’un rang et d’une couleur.

  ○      Un joueur possède une main. Une main contient des cartes à jouer. Un jeu contient des cartes à jouer.

Dans le chapitre suivant, nous commencerons à contrôler le séquençage des événements du jeu.