« JEU DE BELOTE » - Abbas AHMAD AHMAD& Matin BAYRAMOV Page 1 Rapport du projet : Jeu de Belote...

Abbas AHMAD& Matin BAYRAMOV

Rapport du projet : Jeu de Belote 2010

UFR ST – Licence 2 2010/2011

Programmation Orienté Objet 3ème semestre

Programmation Orienté Objet

Rapport du Projet

« JEU DE BELOTE »

Abbas AHMAD & Matin BAYRAMOV

Group TP C

Professeur encadrant :

M. Pierre Alain Masson



Sommaire

Introduction

I. Présentation du jeu de Belote

II. Conception

III.Diagramme de classe

Conclusion



Introduction

Le but de ce projet consiste à programmer une version simplifié du Jeu de

Belote. Après avoir appris la programmation objet orienté, ce projet devrait nous

faire pratiquer l’objet en Java. Contrairement à l’année dernière cette fois nous

étions obligé de programmer le jeu en objet. Nous avons détaillés les

caractéristiques du jeu et les règles dans les parties suivantes. Ensuite nous

avons montrés une vue objet de ce jeu.



I. Présentation du jeu de Belote

Le jeu

Ce jeu est un jeu de cartes qui se joue à quatre avec un paquet de 32

cartes comprenant 4 bois (Pique, Cœur, Carreau et Trèfle) et 8 valeurs. Un de

ces quatre joueurs est un joueur humain, les trois autres joueurs se font jouée

par l’ordinateur.

Pique Cœur Carreau

Trèfle

Les cartes

Une carte a un bois, une valeur et un nombre de points. Exemple :

La valeur d’une carte dépend de si elle est atout ou pas. Au première tour le

joueur humain choisit l’un des bois pour être l’atout de la partie.

Si des cartes ne sont pas des atouts, alors ces valeurs de la plus forte à la moins

forte sont:

Hors atout : As – Dix – Roi – Dame – Valet – Neuf – Huit – Sept.

Si elles sont des atouts, l’ordre change comme suit : toujours de la plus forte à la

moins forte.

A l’atout : Valet – Neuf – As – Dix – Roi – Dame – Huit – Sept.



Les règles

Une fois que l’atout choisi, le joueur humain commence à jouer sa première

carte. Ici il n’est pas obligé de jouer un atout, il peut jouer n’importe quelle carte

qu’il souhaite. On appellera le pli la collection de quatre cartes qui seront sur la

table. Ensuite aux tours des autres joueurs, chaque joueur devrait jouer une

carte du même bois que celle de la première carte du pli. Si un joueur n’en a

pas, il sera obligé de jouer une carte atout. S’il n’a pas d’atout non plus, alors il

est autorisé de jouer une carte quelconque.

Quand chaque jouer à jouer une carte, on dit le pli est terminé et il est

remporté par celui qui a joué la plus forte carte. S’il y des cartes atouts, alors la

carte la plus forte sera l’atout plus fort, en respectant l’ordre que nous avons

présentée au-dessus. S’il n’y a pas d’atout, la carte la plus forte est celle qui est

la plus forte dans le bois de la première carte du pli. Celui qui vient de

remporter le pli commence le pli suivant.

Les équipes

Les joueurs forment deux équipes de deux. Les joueurs 1 et 3 forment

première équipe, et les joueurs 2 et 4 forment deuxième équipe. A la fin de la

partie, chaque équipe compte ses points en additionnant les points des cartes

qu’elle a gagnées. L’équipe qui a remporté le dernier pli a droit à 10 points

supplémentaires. L’équipe qui a plus de points au total remporte la partie.

Les points

Les points des cartes hors atout :

Carte As Dix Roi Dame Valet Neuf Huit Sept

Points 11 10 4 3 2 0 0 0

Les points des cartes à l’atout :

Carte Valet Neuf As Dix Roi Dame Huit Sept

Points 20 14 11 10 4 3 0 0



Début du jeu

Au début du jeu nous affichons les cartes du jeu de belote aux joueurs. On

distribue les cartes puis on lui affiche sa main. Ensuite on lui demande de saisir

l’atout.

k



Apres avoir saisie l’atout on présente au joueur les cartes de sa main en

mettant une étoile devant les cartes atouts, nous demandons ensuite au joueur

de saisir la carte qu’il souhaite jouer.

Lorsque le joueur saisi la carte, on affiche les cartes jouées (le pli), on lui

dit qui remporte la main. Ensuite on lui affiche les cartes qu’il lui reste dans la

main. On annonce le tour de joueur, s’il ne commence pas en premier, on lui

affiche les cartes jouées avant lui et on lui demande de jouer.



Fin du jeu

A la fin du pli numéro 8 (les joueurs ont joué tous leurs cartes), on affiche

qui a gagné le dernier pli, car son équipe remporte dix points supplémentaires.

On annonce l’équipe gagnant et les points des deux équipes. Finalement nous

demandons au joueur s’il veut rejouer.

D



Carte

II. Conception

Il est demandé de programmer le jeu en programmation orienté objet de

Java.

Nous avons caractérisé une carte par son bois, sa valeur et le nombre de

points. Dans ce cas une carte belote est toujours une carte sauf qu’elle a des

propriétés différentes. Cela dit en fait une carte belote est une sorte de carte.

Pour présenter les cartes du jeu, les cartes qui seront dans les mains des

joueurs, les cartes dans le pli et les cartes qui seront ramassées par les joueurs,

nous avons utilisé des listes. Bien entendu nous avons respectés les indications

qui sont été données dans le sujet.

Les listes sont de type CarteBelote.

Une carte belote est une sorte de carte.

CollectionCartes

JeuBelote MainBelote PliBelote CarteRamasser

CarteBelote



Les exceptions

Nous avons fait des exceptions pour vérifier les saisies d’utilisateur. Au cas

où la saisie n’est pas bonne pour que le programme ne se plante pas, on lui

oblige de saisir la bonne demande. Exemples, pour un utilisateur qui ne saisit pas

bien :

Nous avons créé plusieurs exceptions pour les saisies d’utilisateur (voir

diagramme de classe).

Exemple d’exception



Exception sur la saisie d'un atout



III. Diagramme de class

Carteprivé chaine name

privé entier bois

privé entier va leur

privé entier point

Constructeur ()

Constructeur ( va leur, bois )

constructeur (int va leur, int bois , String name)

setName(String name) : rien

getName() : cha ine

setBois (int bois ) :rien

getBois () : entier

setValeur(int va leur) : rien

getValeur() : int

setPoint(int point) :rien

getPoint() : entier

estDeMemeBois (Carte carte) : booleen

getBoisString () : cha ine

getValeurString () : cha ine

toString () : cha ine

CarteBelote herite de Carteprivé booleen isAtout

statique entier nbrCarteBeloteParBois

Constructeur(va leur,bois )

Constructeur(va leur,bois ,name)

setAtout() : rien

setPoint() : rien

isAtout () : booleen

estDeMemeBois (CarteBelote carte) : boolean

isFortThan(CarteBelote carte) : booleen

toString() : cha ine

Jeu

tourJoueur(pl i ) : entier

annonceGagnant(equipe1,equipe2) : rien

RegleJeuentier decision

Ini t() : rien



CollectionCartesl i s te lesCartes

privé s tatic fina l entier nbrMaxCartes

Constructeur()

getLesCartes () : l i s te

setLesCartes (LesCartes ) : rien

addUneCarte ( carte) : rien

removeUneCarte ( carte) : rien

melangeJeu():rien

getPremiereCarte () : CarteBelote

removeCarte ( indice) : CarteBelote

getCarte ( indice) : CarteBelote

possedeLeBois Jouee( carte) : booleen

possedeCarteAtout(): booleen

getPremiereCarteAtout() :CarteBelote

getIndicePremiereCarteAtout() : entier

getPlusFortAtout() : CarteBelote


CarteRamasser herite de CollectionCartes

Constructeur()toString() : chaine

Jeubelote herite de CollectionsCartesprivé s tatic final nbrMaxCartes

Constructeur()

getLesAtouts(): l i s te

getUneCarteAtout() : CarteBelote

MainBelote herite de CollectionCartesprive fina l entier nbrMaxCartes

entier nbrCartes

Constructeur()

rempl i rLaMain(jb) : rien

removeCarte(indice) : CarteBelote

setAtoutMain(atout) : rien

PliBelote Herite de CollectionCartesprive final entier nbrMaxCartes

privé entier nbrcartePl i

Constructeur()

addUneCarte(carte) : rien



Joueurchaine nom

chaine prenom

MainBelote main

CarteRamasser carteRamasser

privé entier score

Constructeur()

Constructeur(nom)

Constructeur(nom,prenom)

setNom(nom): rien

getNom(): cha ine

setPrenom(): rien

getPrenom():chaine

setScore(score): rien

getScore():entier

setMain(main):rien

getMain(): MainBelote

ramasserLesCartes (pl i ) : rien


JoueurHumain herite de Joueur

Constructeur()

Constructeur(nom)


sais i rAtout() : entier

sa is i rCarte(mb) : entier

joueUneCarte(pl i ) : rien

JoueurOrdi herite de Joueur

Constructeur()

Constructeur(nom)


joueUneCarte(pl i ) : rien



Exception

SaisirCarteExcption herite de Exception

Constructeur(s )

SaisieAtouException herite de Exception

Constructeur(s )

MauvaiseSaisieException herite de Exception

Constructeur(s )



Conclusion

Nous avons créé des méthodes utiles pour un jeu belote réel dans les

classes. En effet nous avions prévus d’avoir programmer le jeu belote réel. Par

contre le temps pour rendre le projet était un peu court, alors nous ne sommes

pas arrivés à le faire. Comme nous avons vu un peu d’interface graphique, nous

avons eu le souhait de réaliser une interface graphique pour ce projet. Ce qui n’a

pas été le cas pour faute de temps. Des remerciements à notre professeur

encadrant M. Pierre Alain Masson.

« JEU DE BELOTE » - Abbas AHMAD AHMAD& Matin BAYRAMOV Page 1 Rapport du projet : Jeu de Belote...

Documents

Transcript of « JEU DE BELOTE » - Abbas AHMAD AHMAD& Matin BAYRAMOV Page 1 Rapport du projet : Jeu de Belote...