Commençons à coder! Pour appliquer les principes SOLID et l'architecture MVC, nous allons développer ensemble un jeu de cartes dont les règles seront simples. Nous créerons un jeu classique de 52 cartes. Nous disposerons d'un nombre paramétrable de joueurs et distribuerons une carte à chaque joueur ; le gagnant sera celui qui aura la plus forte.Nous allons coder la base du jeu puis effectuer des modifications au fur et à mesure du cours. Nous modifierons ensuite les règles ainsi que le jeu de cartes. Nous ajouterons une GUI (interface utilisateur graphique). Si nous observons les principes SOLID et l'approche MVC, l'impact de nos modifications sera réduit.
Voyons les exigences de l'application.
Règles du jeu (spécifications fonctionnelles) :
Créer un jeu classique de 52 cartes.
Entrer les noms des joueurs. Limiter le nombre de joueurs à cinq.
Mélanger les cartes.
Distribuer une carte à chaque joueur (face cachée).
Retourner les cartes de tous les joueurs, afin qu'elles soient visibles.
Identifier le joueur ayant la carte dont la valeur est la plus forte : As > Roi > Reine > Valet > 10 > . . . 2.
En cas d'égalité, le choix du gagnant s'effectue en fonction de la couleur :
Trèfle > Pique > Cœur > Carreau
Présenter le nom et la carte du joueur gagnant.
Remettre toutes les cartes dans le jeu.
Recommencer à mélanger les cartes.
Concevez le modèle
Identifions les principaux éléments que les joueurs verront et avec lesquels ils interagiront. La méthode la plus simple pour trouver des objets de modèle consiste à parcourir les exigences fonctionnelles à la recherche des noms (substantifs). En lisant la description, vous trouvez : un jeu de cartes, des joueurs, des valeurs et des couleurs de carte.
Comment mettre en lien les joueurs et leur carte ? Un joueur sera en possession d'une carte durant le jeu, n'est-ce pas ?
Même si cela n'est pas explicitement mentionné, la carte unique détenue par un joueur est intégrée à une classe Hand (une main, c'est-à-dire l'ensemble des cartes détenues par un joueur). Cela reste conforme au principe de responsabilité unique.
Un joueur se définit par son nom et sa main. Si les règles viennent à changer, il est probable que cela concernera le nombre de cartes détenues dans une main ou un détail dans la façon de manipuler les cartes. Vous n’aurez donc pas à modifier le modèle de base d'un joueur si vous modifiez les règles du jeu.
Implémentez le modèle
À présent, vous allez devoir créer des classes Java pour chacun des éléments du modèle. Faisons cela ensemble !
Étape 1 : coder la valeur et la couleur
Nous avons créé :
Rank.java(une énumération de 2 à as, l'as étant la valeur la plus forte) ;Suit.java(une énumération des couleurs, trèfle étant la couleur la plus forte).
Étape 2 : coder une carte
Nous avons créé :
PlayingCard.java(une valeur, une couleur et un flag indiquant si la carte est face visible ou cachée).
Étape 3 : créer un jeu
Nous avons créé :
Deck.java(un ensemble de cartes à jouer).
Étape 4 : créer une main et un joueur
Nous avons créé :
Hand.java(un ensemble de cartes de jeu détenues par un joueur) ;Player.java(un nom et une main).
À mesure que nous coderons le jeu, en conformité avec les principes SOLID, nous modifierons tout cela. Dans le chapitre suivant, nous allons commencer à travailler sur le contrôleur et l’affichage en ligne de commande.
En résumé
Le modèle se compose des éléments avec lesquels vous entrez en interaction. Ces derniers contiennent les informations d'état du système.
Pour identifier vos objets de modèle, référez-vous aux exigences de votre projet.
Dans notre application, nous avons défini ce qui suit :
le modèle se compose d'un joueur, d'une main, d'une carte, d'un jeu, d'une valeur et d'une couleur ;
un joueur a un nom et une main. Une main se compose d'une carte à jouer. Un jeu se compose de plusieurs cartes à jouer.
Dans le chapitre suivant, nous nous occuperons de l'enchaînement des événements du jeu.
