Objectif acad$$mique : Manipuler les concepts orient$$s objet en C#$.$

Objectif applicatif : D$$velopper une mini application de jeux de cartes.

Remise : Voir le portail des travaux

Le code source remis via Gitlab.

Aucun code source remis autrement ne sera accept$!$

Un document sur le portail des travaux contenant

Une page de pr$$sentation du groupe.

Liste des concepts.

Un diagramme de classes.

Le lien vers la branche Gitlab du projet contenant le programme.

Sujet : Voir page suivante

Sujet :

Utiliser les concepts ad$$quats $($ class, struct, interface$)$ pour impl$$menter un jeu de cartes de $52$ Cartes.

Valeurs : As$,2,3,4,5,6,7,8,9,10,$ Valet, Dame, Roi$($Jack$)$

Couleurs : Tr$$fle$,$ Carreau, C$$ur$,$ Pique.

Une carte $$ une valeur et une couleur qui vont d$$terminer son nom

Exemples de cartes : As de Tr$$fle$,$ Roi de Pique...

Un jeu complet appel$$ Paire de Cartes $($Toutes les combinaisons simples possibles$)$ contient $52$

cartes.

Nous voulons $$ pr$$sent faire une partie de $$P$$che$|$ Pioche$($un jeu de cartes$).$

Une partie peut se faire avec $2,3$ ou $4$ joueurs.

Les joueurs sont des personnes avec nom et pr$$nom et un identifiant unique.

Chaque joueur $$ une main qui peut contenir $8$ cartes au plus.

Pour d$$marrer une partie, il faudra distribuer le m$$me nombre de cartes $(8)$ al$$atoirement $$ chaque

joueur. Le reste des cartes est d$$pos$$ sur la pile de cartes appel$$e $$ pioches $$ de la table de jeu.

Quand la partie d$$marre$.$

Un joueur est choisi al$$atoirement pour commencer la partie en posant une carte ouverte sur la

table, dans la pile nomm$$e $$ d$$p$$t $.$

Le joueur suivant doit d$$poser une carte de m$$me couleur ou de m$$me valeur sur la pile de

d$$p$$t$.$

$$ d$$faut$,$ il devra piocher une carte sur la pile de pioche et son tour passe au prochain.

Ainsi de suite...

Quand la pile de pioches est finie, la pile de d$$p$$t$($m$$lang$$e$)$ va $$tre r$$utilis$$e comme pile de

pioches.

Quand un joueur termine ses cartes, il gagne la partie.

$1-$ Impl$$mentez tous les concepts du domaine et leurs types. $(10\%)$

a$.$ Carte : struct $($OBLIGATOIREMENT$)$

b$.$ Couleur : $?$

c$.$ Valeur : $?$

d$.$ Joueur : $?$

e$.$ Personne : $?$

f$.$ PaireDeCartes : $?$

g$.$ TableDeJeu : $?$

h$.$ JeuxDeP$$che: $?$

i$.$ PileDePioche : $?$

j$.$ PileDeDep$$t : $?$

Vous devez d$$terminer si ces concepts OBLIGATOIRES sont des class $?$ interface $?$ struct $?$ enum.

$2-$ Donner un diagramme de classes des concepts. $(15\%)$

a$.$ Liens

b$.$ Types de liens

c$.$ Quelques variables membres importantes.

Ne faire pas de r$$tro$-$ing$$nierie pour le diagramme de classe.

$3-$ Impl$$menter la paire de $52$ cartes $(20\%)$

$4-$ Impl$$menter le jeu de $$ p$$che $(20\%)$

a$.$ Lancer et Logger $($Console$.$WriteLine$)$ une partie qui se joue avec $3$ joueurs.

i$.$ Distribuer les cartes al$$atoirement$,$ et choisir le premier $$ jouer.

A chaque tour de joueur : $($utiliser le pattern observateur$)$

Afficher le joueur qui a jou$,$ et la carte qu'il a jou$$e

La derni$$re carte sur la pile de d$$p$$t$.$

ii$.$ Signaler la fin de la pile de pioches.

iii. Signaler la fin du jeu et le vainqueur.

b$.$ Retarder les traitements avec delay et await.

c$.$ Le jeu doit se faire automatiquement $($pour faciliter la correction$)$

$5-$ Sachant que l'as compte pour $11$ points, valet, dame et roi comptent pour $2$ points et que les

autres cartes comptent pour leur valeurs faciales $(7->7$ points, $3->3$points...etc.$)(20\%)$

a$.$ Calculer le bilan de chaque joueur $$ la fin de la partie. $($quand un joueur termine$)$

b$.$ Impl$$menter une strat$$gie qui permet $$ tous les coups de minimiser le d$$compte de

point $$ la fin du jeu.

c$.$ Quand un joueur n$\text{'}$A plus qu'une carte, l'ensemble des joueurs doivent $$tre notifier et

adapter leur strat$$gie$.$

d$.$ Le $10$ permet de changer l'orientation du flux de jeux.

e$.$ Appliquer al$$atoirement cette strat$$gie a un joueur.

$6-$ Architecture : $10$

a$.$ EVITER D'UTILISATION DES VARIABLES STATIQUES sauf pour les const

b$.$ Utilisation du pattern Observateur au standard de C# $($OBLIGATOIRE$)$

c$.$viter l'anti$-$pattern God$-$Class $($une classe qui fait tout$).$

d$.$ Distribuer les responsabilit$$s aux classes

$7-$crire un code lisible $10\%$

a$.$ Commentaires

b$.$ Namespaces, Organisation.