Un petit jeu nous a été demandé de réaliser a la FAC ...
J'ai pas eu le choix, j'ai donc fais un jeu de poker.
Il fallait que ca tourne sous UNIX (compilation g++) et sous windows (.net) et le tout en mode console ...
c'est pas beau graphiquement mais ca tourne... surtout qu'on a pas eu beacoup de temps ...
juste un petit bug a corriger....
les commantaires et conseils sont les bien venus ... merci
le jeu est orienté objet a 100%... j'utilise les tres pratiques deque et vector, la méthode .at() de vector et deque n'est pas utilisé, met des que je me penche un peut sur la gestion des exception avec c++ je m'en charge :))
Source / Exemple :
/***************************************************************************
Cartes.cpp - description
-------------------
begin :
copyright : (C) 2002 by J. Hamard
email : juju.hamard@wanadoo.fr
/***************************************************************************
- *
- This program is free software; you can redistribute it and/or modify *
- it under the terms of the GNU General Public License as published by *
- the Free Software Foundation; either version 2 of the License, or *
- (at your option) any later version. *
- *
/***********************
Jeu de 52 cartes :
valeur couleur
0 treffle
1 carreau
2 2 coeur
3 3 pique
4 4
5 5
6 6
7 7
8 8
9 9
10 10
11 valet
12 dame
13 roi
14 As
#include "cartes.h"
#include <iostream>
#include <string>
/////////////////////////////////
// Fonction Membre de Cartes //
/////////////////////////////////
/* Constructeurs */
Carte::Carte(){
};
Carte::Carte(const Carte& original){
couleur = original.getCouleur();
valeur = original.getValeur();
};
Carte::Carte(unsigned val, unsigned coul){
couleur = coul;
valeur = val;
};
/* Destructeurs */
Carte::~Carte(){
};
/* Surdefinition */
bool operator==(const Carte& carte1, const Carte& carte2){
return ((carte1.getCouleur() == carte2.getCouleur()) &&
(carte1.getValeur() == carte2.getValeur()));
}; // bool operator==(const Carte& carte1, const Carte& carte2)
Carte& Carte::operator=(const Carte& carte1){
if (this == &carte1) return *this;
valeur = carte1.getValeur();
couleur = carte1.getCouleur();
return *this;
}; // Carte& Carte::operator=(const Carte& carte1)
ostream& operator<<(ostream& os, const Carte& arg){
os << "\xda\xc4\xc4\xc4\xc4\xc4\xbf" << endl; // affichage de la premier ligne de la carte
//os << "\xb3 \xb3" << endl; // affichage de la deuxieme ligne
switch (arg.getCouleur()) // affichage de la couleur
{
case 0:
os << "\xb3\5 \5\xb3" << endl;
break;
case 1:
os << "\xb3\4 \4\xb3" << endl;
break;
case 2:
os << "\xb3\3 \3\xb3" << endl;
break;
case 3:
os << "\xb3\6 \6\xb3" << endl;
break;
default:
os << "Erreur dans la couleur de la carte: " << arg.getCouleur();
}
switch (arg.getValeur()) // affichage de la valeur
{
case 2:
os << "\xb3 2 \xb3";
break;
case 3:
os << "\xb3 3 \xb3";
break;
case 4:
os << "\xb3 4 \xb3";
break;
case 5:
os << "\xb3 5 \xb3";
break;
case 6:
os << "\xb3 6 \xb3";
break;
case 7:
os << "\xb3 7 \xb3";
break;
case 8:
os << "\xb3 8 \xb3";
break;
case 9:
os << "\xb3 9 \xb3";
break;
case 10:
os << "\xb3 1 0 \xb3";
break;
case 11:
os << "\xb3Valet\xb3";
break;
case 12:
os << "\xb3" << "Da me\xb3";
break;
case 13:
os << "\xb3 Roi \xb3";
break;
case 14:
os << "\xb3 A s \xb3";
break;
default:
if (!((arg.getValeur()>1) && (arg.getValeur()<11)))
os << "Erreur dans la valeur de la carte: " << arg.getValeur();
}
os << endl << "\xc0\xc4\xc4\xc4\xc4\xc4\xd9"; // affichage derniere ligne
return os;
}; // ostream& operator<<(ostream& os, const Carte& arg)
/* Fonctions membres */
unsigned Carte::getCouleur() const{
return couleur;
};
unsigned Carte::getValeur() const{
return valeur;
};
char Carte::symbole() const{
switch (getCouleur()) // symbole de la couleur
{
case 0:
return '\5';
break;
case 1:
return '\4';
break;
case 2:
return '\3';
break;
case 3:
return '\6';
break;
default:
return '$';
break;
}
}; // char Carte::symbole() const
string Carte::nomValeur() const{
switch (getValeur()){ // Valeur
case 2:
return "2";
break;
case 3:
return "3";
break;
case 4:
return "4";
break;
case 5:
return "5";
break;
case 6:
return "6";
break;
case 7:
return "7";
break;
case 8:
return "8";
break;
case 9:
return "9";
break;
case 10:
return "10";
break;
case 11:
return "Valet";
break;
case 12:
return "Dame";
break;
case 13:
return "Roi";
break;
case 14:
return "As";
break;
default:
return "Erreur dans le nom de la carte " + getValeur() + ',' + getCouleur();
break;
};
};
string Carte::designation() const{
return nomValeur() + " de " + symbole() ;
}; // string Carte::nomValeur() const
/***************************************************************************
jeuCartes.cpp - description
-------------------
begin :
copyright : (C) 2002 by J. Hamard
email : juju.hamard@wanadoo.fr
/***************************************************************************
- *
- This program is free software; you can redistribute it and/or modify *
- it under the terms of the GNU General Public License as published by *
- the Free Software Foundation; either version 2 of the License, or *
- (at your option) any later version. *
- *
/***********************
Jeu de 52 cartes :
------------------
valeur couleur
0 carreau
1 coeur
2 2 pique
3 3 treffle
4 4
5 5
6 6
7 7
8 8
9 9
10 10
11 valet
12 dame
13 roi
14 as
#include "jeuCartes.h"
#include <iostream>
#include <algorithm>
#include <time.h>
/////////////////////////////////
// Fonction Membre de JeuCarte //
/////////////////////////////////
/* Constructeurs */
JeuCarte::JeuCarte(){
for(unsigned coul=0; coul<4; coul++)
for(unsigned val=2; val<15; val++)
jeuCarte.push_back(Carte(val, coul));
}; // JeuCarte()
/* Destructeur */
JeuCarte::~JeuCarte(){
jeuCarte.clear();
}; // ~JeuCarte()
/* Surdefinition */
ostream& operator<<(ostream& os, const JeuCarte& arg){
for(size_t i = 0; i < arg.jeuCarte.size(); i++){
os << arg.jeuCarte[i];
os << endl;
}
return os;
}; // ostream& operator<<(ostream& os, const JeuCarte& arg)
/* Accesseurs */
int JeuCarte::melanger(){
if (jeuCarte.empty())
return EXIT_FAILURE;
srand((unsigned)time(NULL));
random_shuffle(jeuCarte.begin(), jeuCarte.end());
return EXIT_SUCCESS;
}; // int JeuCarte::melanger()
Carte JeuCarte::popCarte(){
Carte tmpCarte;
//if (!jeuCarte.empty()){
tmpCarte = jeuCarte[0]; // recupere la premiere carte
jeuCarte.pop_front(); // supprime la premiere sur le tas
return tmpCarte;
//}
}; // Carte JeuCarte::popCarte()
int JeuCarte::pushCarte(Carte newCarte){
if (jeuCarte.size()>51) // deja 52 cartes dan le paquet
return EXIT_FAILURE;
jeuCarte.push_back(newCarte); // ajout de la carte a la fin du jeu
return EXIT_SUCCESS;
}; // int JeuCarte::pushCarte(Carte newCarte)
/***************************************************************************
Joueur.cpp - description
-------------------
begin :
copyright : (C) 2002 by J. Hamard
email : juju.hamard@wanadoo.fr
/***************************************************************************
- *
- This program is free software; you can redistribute it and/or modify *
- it under the terms of the GNU General Public License as published by *
- the Free Software Foundation; either version 2 of the License, or *
- (at your option) any later version. *
- *
#include "joueur.h"
#include <string>
#include <iostream>
/////////////////////////////////
// Fonction Membre de JeuCarte //
/////////////////////////////////
/* Constructeurs */
Joueur::Joueur(){
};
Joueur::Joueur(string stVal, int intVal){
nom = stVal;
score = intVal;
};
/* Destructeurs */
Joueur::~Joueur(){
};
/* Surdefinition */
ostream& operator<<(ostream& os, const Joueur& arg){
os << "Nom: " << arg.nom;
os << endl << "Score: " << arg.score;
return os;
}; // ostream& operator<<(ostream& os, const Joueur& arg)
/* Accesseurs */
void Joueur::init(string stArg, int intArg){
nom = stArg;
score = intArg;
}; // void Joueur::init(string stArg, int intArg)
string Joueur::getNom(){
return nom;
};
unsigned Joueur::getScore(){
return score;
};
void Joueur::letScore(unsigned newScore){
score = newScore;
};
/***************************************************************************
mainCartes.cpp - description
-------------------
begin :
copyright : (C) 2002 by J. Hamard
email : juju.hamard@wanadoo.fr
/***************************************************************************
- *
- This program is free software; you can redistribute it and/or modify *
- it under the terms of the GNU General Public License as published by *
- the Free Software Foundation; either version 2 of the License, or *
- (at your option) any later version. *
- *
#include "mainCartes.h"
#include <iostream>
#include <algorithm>
/////////////////////////////
// Fonction Membre de Main //
/////////////////////////////
/* Constructeurs */
Main::Main(){
score = 0;
nbCartes = 0;
paire = 0;
for(int i=0; i<3; i++) valPaire[i] = 0; // (1ere paire, 2eme paire, triple)
}; // Main()
/* Destructeurs */
Main::~Main(){
mainCarte.clear();
}; // ~Main()
/* Surdefinition */
ostream& operator<<(ostream& os, Main& arg){
// for(size_t i = 0; i < arg.mainCarte.size(); i++){
// os << arg.mainCarte[i];
// os << endl;
// }
// Affiche le numéro de carte
os << "\t\t\t";
for(unsigned i = 0; i < arg.mainCarte.size(); i++)
os << " " << i+1 << " \t";
os << endl;
// Affiche le haut de la carte
os << "\t\t\t";
for(size_t i = 0; i < arg.mainCarte.size(); i++)
os << "\xda\xc4\xc4\xc4\xc4\xc4\xbf\t";
os << endl;
// Affiche le Symbole de la carte
os << "\t\t\t";
for(size_t i = 0; i < arg.mainCarte.size(); i++)
os << "\xb3" << arg.mainCarte[i].symbole()
<< " " << arg.mainCarte[i].symbole() << "\xb3\t";
os << endl;
// Affiche une ligne vide
os << "\t\t\t";
for(size_t i = 0; i < arg.mainCarte.size(); i++)
os << "\xb3 \xb3\t";
os << endl;
// Affiche la valeur de la carte
os << "\t\t\t";
string tmpString;
for(size_t i = 0; i < arg.mainCarte.size(); i++){
tmpString = arg.mainCarte[i].nomValeur();
os << "\xb3";
for(int j = 0; j < (int)(5-((int)((5-tmpString.length())/2) + tmpString.length())); j++)
os << " ";
os << tmpString;
for(int j = 0; j < (int)(5-tmpString.length())/2; j++)
os << " ";
os << "\xb3\t";
}
os << endl;
// Affiche une ligne vide
os << "\t\t\t";
for(size_t i = 0; i < arg.mainCarte.size(); i++)
os << "\xb3 \xb3\t";
os << endl;
// Affiche le Symbole de la carte
os << "\t\t\t";
for(size_t i = 0; i < arg.mainCarte.size(); i++)
os << "\xb3" << arg.mainCarte[i].symbole()
<< " " << arg.mainCarte[i].symbole() << "\xb3\t";
os << endl;
// Affiche le bas de la carte
os << "\t\t\t";
for(size_t i = 0; i < arg.mainCarte.size(); i++)
os << "\xC0\xc4\xc4\xc4\xc4\xc4\xd9\t";
return os;
}; // ostream& operator<<(ostream& os, Main& arg)
/* Fonctions Membres */
Carte Main::getCarte(unsigned num){
Carte tmpCarte;
/* retour de la carte choisie */
tmpCarte = mainCarte[(size_t)(num)];
IterMainCarte = mainCarte.begin() + num;
mainCarte.erase(IterMainCarte);
--nbCartes;
return tmpCarte;
}; // Carte Main::getCarte(unsigned num)
unsigned Main::getScore(){
return score;
}; // unsigned Main::getScore()
unsigned Main::getNbCartes(){
return nbCartes;
}; // unsigned Main::getNbCartes(){
int Main::addCarte(Carte nouvelleCarte){
if ((mainCarte.size()>4) || // si il y a deja 5 cartes dans la main
isPresent(nouvelleCarte)) // si la carte est deja presente
return EXIT_FAILURE; // exit code -1
/* ajout de la carte a la fin */
mainCarte.push_back(nouvelleCarte);
++nbCartes;
return trier();
}; // int Main::addCarte(Carte nouvelleCarte)
int Main::delCarte(unsigned numCarte){
if (mainCarte.size() < 1) // si les valeurs sont mauvaises
return EXIT_FAILURE; // exit code = -1
if ((numCarte<1) || (numCarte > mainCarte.size()))
return EXIT_FAILURE; // la carte n'est pas trouvee
/* suppression de la carte */
IterMainCarte = mainCarte.begin() + --numCarte;
mainCarte.erase(IterMainCarte);
--nbCartes;
return trier();
}; // int Main::delCarte(unsigned numCarte)
bool Main::isSuite(){
if (mainCarte.size() < 5) // pas 5 cartes dans la main
return false;
if ((mainCarte[0].getValeur() == mainCarte[1].getValeur() -1) &&
(mainCarte[1].getValeur() == mainCarte[2].getValeur() -1) &&
(mainCarte[2].getValeur() == mainCarte[3].getValeur() -1) &&
(mainCarte[3].getValeur() == mainCarte[4].getValeur() -1)) // suite
return true;
else // pas suite
return false;
}; // bool Main::isSuite()
bool Main::isCouleur(){
if (mainCarte.size() < 5) // pas 5 cartes dans la main
return false;
if ((mainCarte[0].getCouleur() == mainCarte[1].getCouleur()) &&
(mainCarte[1].getCouleur() == mainCarte[2].getCouleur()) &&
(mainCarte[2].getCouleur() == mainCarte[3].getCouleur()) &&
(mainCarte[3].getCouleur() == mainCarte[4].getCouleur())) // couleur
return true;
else // pas couleur
return false;
}; // bool Main::isCouleur()
void Main::compterPaires(){
paire = 0;
for(int i=0; i<3; i++) valPaire[i] = 0; // (1ere paire, 2eme paire, triple)
int tmp = 0;
for(unsigned i=0; i < mainCarte.size()-1;){
if (mainCarte[i].getValeur() == (mainCarte[(i+1)%5]).getValeur())
if (mainCarte[i].getValeur() == (mainCarte[(i+2)%5]).getValeur())
if (mainCarte[i].getValeur() == (mainCarte[(i+3)%5]).getValeur()){ // quadruple
valPaire[2] = i;
paire+=5;
IterMainCarte+=4;
} else{ //triple
valPaire[2] = i;
paire+=3;
i += 3;
}
else{ // double
valPaire[tmp++] = i;
paire+=1;
i += 2;
}
else
i++; // carte
};
} // void Main::compterPaires()
bool lowerValeurCarte(Carte elem1, Carte elem2){
if (elem1.getValeur() < elem2.getValeur())
return true; // elem1 < elem2
else
if (elem1.getValeur() == elem2.getValeur())
return (elem1.getCouleur() < elem2.getCouleur()); // elem1 < elem2
else
return false; // elem1 > elem2
}; // bool lowerCarte(Carte elem1, Carte elem2)
bool lowerCouleurCarte(Carte elem1, Carte elem2){
return (elem1.getCouleur() < elem2.getCouleur());
}; // bool lowerCouleurCarte(Carte elem1, Carte elem2)
int Main::trier(){
if (mainCarte.size() < 1) // si il n'y a de carte
return EXIT_FAILURE;
sort(mainCarte.begin(), mainCarte.end(), lowerValeurCarte);
return EXIT_SUCCESS;
}; // int Main::trier()
string Main::qualite(){
/* Valeurs retournees:
Carte : 00 00 xx (x = valeur de la plus grosse carte)
Paire : 10 00 aa (a = valeur des cartes identiques)
2 Paires : 20 aa bb (a & b = valeur de la paire)
Brelan : 30 00 aa (a = valeur des cartes identiques)
Suite : 40 00 xx (x = valeur de la plus grosse carte de la suite)
Couleur : 50 00 cc (c = couleur de la suite)
Full : 60 aa bb (a = valeur du brelan; b = valeur de la paire)
Carre : 70 00 aa (a = valeur des cartes identiques)
Quinte Flush : 80 cc xx (c = couleur de la suite; x = valeur de la plus grosse carte)
/* 1) Compter les paires
12345 -> 0 paire
11234 -> 1 paire
11123 -> 3 paires
11122 -> 4 paires
11113 -> 5 paires
/* le tableau est trie sur les valeurs croissantes */
/* comptage des paires
stock les numero de carte dans le tableau: valPaire[]*/
compterPaires();
/* evaluation de la qualité du jeu */
string tmpResult = "";
switch (paire){
case 0:{
/* comptage de suite */
bool suite = isSuite();
/* verifie si il y a couleur */
bool couleur = isCouleur();
/* Calcul de la qualite */
if (couleur)
if (suite){ // quinte flush
score = (800 + mainCarte[0].getCouleur()*10 + mainCarte[4].getValeur());
tmpResult = "Quinte Flush de " + mainCarte[0].getCouleur(), " + plus forte carte: " + mainCarte[4].nomValeur();
}else{ // couleur
score = (500 + mainCarte[0].getCouleur());
tmpResult = "Couleur a " + mainCarte[0].getCouleur(), " + plus forte carte: " + mainCarte[4].nomValeur();
}
else // pas une couleur
if (suite){ // suite
score = (400 + mainCarte[4].getValeur());
tmpResult = ("Suite, plus forte carte: " + mainCarte[4].designation());
}else{ // Carte
score = mainCarte[4].getValeur();
tmpResult = ("Carte, plus forte carte: " + mainCarte[4].designation());
};
break;
}
case 1:{ // 1 paire
score = (100 + mainCarte[valPaire[0]].getValeur());
tmpResult = "Paire de " + mainCarte[valPaire[0]].nomValeur();
break;
}
case 2:{ // 2 paires
score = (200 + mainCarte[valPaire[0]].getValeur()*10 + mainCarte[valPaire[1]].getValeur());
tmpResult = "Paire de " + mainCarte[valPaire[0]].nomValeur() + " et une de " + mainCarte[valPaire[1]].nomValeur();
break;
}
case 3:{ // Brelan
score = (300 + mainCarte[valPaire[2]].getValeur());
tmpResult = "Brelan de " + mainCarte[valPaire[2]].nomValeur();
break;
}
case 4:{ // Full
score = (600 + mainCarte[valPaire[2]].getValeur()*10 + mainCarte[valPaire[0]].getValeur());
tmpResult = "Full aux " + mainCarte[valPaire[2]].nomValeur() + " par les " + mainCarte[valPaire[0]].nomValeur();
break;
}
case 5:{ // Carre
score = (700 + mainCarte[valPaire[2]].getValeur());
tmpResult = "Carre de " + mainCarte[valPaire[2]].nomValeur();
break;
}
default:{
score = 0;
tmpResult = "Erreur dans la methode: string Main::qualite()";
break; // erreur lors de la recherche de la qualite
}
};
return tmpResult;
}; // string Main::qualite()
int Main::valeursOk(unsigned val, unsigned coul){
// renvoie -1 si les valeurs de la carte sont erronees
// renvoie 0 si les valeurs de la carte sont coherentes
if (!((val <= 13)||(val > 0) || (coul <= 13)||(coul > 0)))
return EXIT_FAILURE;
return EXIT_SUCCESS;
}; // int Main::valeursOk(unsigned val, unsigned coul)
bool Main::isPresent(Carte& uneCarte){
for(IterMainCarte = mainCarte.begin(); IterMainCarte != mainCarte.end(); IterMainCarte++)
if (uneCarte == *IterMainCarte)
return true;
return false;
}; // bool Main::isPresent(Carte& uneCarte)
bool Main::isPresent(Carte& uneCarte, unsigned& position){
unsigned i;
for(i=0, IterMainCarte = mainCarte.begin(); IterMainCarte != mainCarte.end(); IterMainCarte++, i++)
if (uneCarte == *IterMainCarte){
position = i;
return true;
}
return false;
}; // bool Main::isPresent(Carte& uneCarte, unsigned position)
int Main::cmpWith(Main* laMain){
// Calcul de la qualite de chaque main
qualite();
laMain->qualite();
// Comparaison des scores
return ((score > laMain->score) ? 1 : ((score < laMain->score) ? -1 : 0));
}; // int Main::cmpWith(Main* laMain)
bool Main::peutFaireSuite(unsigned carteAChanger){
unsigned tmpCouleur1;
unsigned tmpCouleur2;
bool tmpResultat;
// trier la main sur les couleurs
sort(mainCarte.begin(), mainCarte.end(), lowerCouleurCarte);
//cout << *this;
tmpCouleur1 = mainCarte[0].getCouleur(); // memorise la premiere couleur
unsigned i =1;
while (tmpCouleur1 == mainCarte[i].getCouleur() && i<nbCartes){ // cherche la premiere carte
i++; // avec une couleur differente
}
if (nbCartes-1 == i){ // toutes les cartes sont identiques sauf la derniere
carteAChanger = i; // il faut changer la derniere carte
tmpResultat = true;
}
else{ // toutes les cartes ne sont pas identiques a la premiere
if (1 == i){
tmpCouleur2 = mainCarte[i].getCouleur(); // memorise la deuxieme couleur
while (tmpCouleur2 == mainCarte[i].getCouleur() && i<nbCartes){ // cherche la premiere carte
i++; // avec une couleur differente
}
if (nbCartes == i){ // toutes les cartes sont identiques sauf la premiere
carteAChanger = 0; // il faut chager la premiere carte
tmpResultat = true;
}else // trop de cartes differentes
tmpResultat = false;
}else // trop de cartes differentes
tmpResultat = false;
}
if (tmpResultat){ // il n'y a qu'une seule carte a changer
// fait une copie de la carte
//Carte tmpCarte(mainCarte[carteAChanger]);
Carte* ptrCarte = &mainCarte[carteAChanger];
//cout << "Carte pointe" << *ptrCarte;
// trier la main sur les valeurs
sort(mainCarte.begin(), mainCarte.end(), lowerValeurCarte);
isPresent(*ptrCarte, carteAChanger); // recupere la position de la carte dans le jeu trier par valeur
}
return tmpResultat;
}; // bool Main::peutFaireSuite(unsigned carteAChanger)
deque<unsigned> Main::cartesAChanger(){
deque<unsigned> tabCartesAChanger;
compterPaires();
if (paire > 3) // le jeu est mieu qu'un Brelan
return tabCartesAChanger; // rien a changer
else{ // possibilite d'ameliorer le jeu
switch (paire){
case 0:{
unsigned i = 0;
if (peutFaireSuite(i)) // peut faire une suite en changeant une carte
tabCartesAChanger.push_back(i);
else // CHANGER toutes les cartes sauf les deux plus fortes
for(i=0; i<(nbCartes-2); i++)
tabCartesAChanger.push_back(i);
break;
}
case 1:{ // CHANGER toutes les cartes sauf la paire
for(unsigned i=0; i<3; i++)
tabCartesAChanger.push_back((valPaire[0]+2+i)%5);
break;
}
case 2:{ // CHANGER la carte qui n'est pas dans une paire -> faire un Full
unsigned i;
// i va POINTER sur la carte qui n'est pas une paire
for(i=0; (i == valPaire[0] ||
i == valPaire[0]+1 ||
i == valPaire[1] ||
i == valPaire[1]+1); i++);
tabCartesAChanger.push_back(i);
break;
}
case 3:{ // CHANGER les deux cartes qui ne font pas partie du brelan -> faire un Carre ou Full
tabCartesAChanger.push_back((valPaire[2]+3)%5);
tabCartesAChanger.push_back((valPaire[2]+4)%5);
break;
}
default:
break;
}
};
return tabCartesAChanger;
}; // deque<unsigned> cartesAChanger()
/***************************************************************************
poker.cpp - description
-------------------
begin :
copyright : (C) 2002 by J. Hamard
email : juju.hamard@wanadoo.fr
/***************************************************************************
- *
- This program is free software; you can redistribute it and/or modify *
- it under the terms of the GNU General Public License as published by *
- the Free Software Foundation; either version 2 of the License, or *
- (at your option) any later version. *
- *
#include "jeuCartes.h"
#include "mainCartes.h"
#include "joueur.h"
#include <algorithm>
#include <iostream>
#include <string>
#include <deque>
using namespace std;
/***************************
- Prototypes des fonctions *
int sToU(char*, deque<unsigned>&); // conversion d'un char* en deque<unisigned>
bool isPresent(deque<unsigned>&, unsigned); // true si val est present dans deque
unsigned intLen(int); // compte le nombre de chiffre dans un nombre
void afficheEntete(); // Affiche l'entete du jeu
void sauterLigne(unsigned); // Saute un certain nombre de ligne a l'ecran
const unsigned miseMini = 25;
/****************
int main(){
char choix; // choix du joueur sur le deroulement du jeu
bool blnRejouer = false;
bool blnSaisieOk = true;
char* tmpString = new char;
deque<unsigned> tabNumCarte;
// AFFICHAGE de l'entete du jeu
afficheEntete();
// CREATION du jeu de carte et melange
JeuCarte jeu;
jeu.melanger();
// CREATION des joueurs
Joueur homme, pc;
sauterLigne(11);
cout << "\tEntrez votre pseudonyme: " << flush;
string tmpNom;
cin.sync(); // Synchronisation de l'input
cin >> tmpNom;
cout.flush();
// INITIALISATION des joueurs
homme.init(tmpNom, 500);
pc.init("IntelP4", 500);
do{ /* DEBUT de partie (la partie dure jusqu'a epuisement des points
ou lorsque le joueur decide d'arreter) */
// CREATION des mains des joueurs
// REPLACE les cartes des joueurs a le fin du jeu
unsigned tmpNbCartes = homme.mainCarte.getNbCartes();
for(unsigned i=0; i<tmpNbCartes; i++){
jeu.pushCarte(homme.mainCarte.getCarte(0));
jeu.pushCarte(pc.mainCarte.getCarte(0));
};
// TIRE les nouvelles cartes
for(int i=0; i<5; i++){
homme.mainCarte.addCarte(jeu.popCarte());
pc.mainCarte.addCarte(jeu.popCarte());
}
// AFFICHAGE des mains
sauterLigne(20);
afficheEntete();
sauterLigne(15);
cout << "\tC'est la main de " << homme.getNom();
sauterLigne(2);
cout << homme.mainCarte;
sauterLigne(2);
// AFFICHAGE de la qualite
cout << "\tQualite du jeu : " + homme.mainCarte.qualite();
sauterLigne(2);
do{ // DEMANDE si changer les cartes
cout << "\tVoulez vous changer des cartes ? (o/n): " << flush;
choix = ' ';
cin.sync(); // Synchronisation de l'input
cin >> choix;
cin.get();
} while (!(choix == 'o' || choix == 'O' ||
choix == 'n' || choix == 'N'));
if ((choix == 'o') || (choix == 'O')){
do{ // CHOIX des cartes a changer
cout << "\tQuelques cartes sont a changer? (ex: 1 3 5): " << flush;
strcpy(tmpString, "");
cin.sync(); // Synchronisation de l'input
cin.getline(tmpString, 100, '\n');
tabNumCarte.clear(); // réinitialisation du deque
blnSaisieOk = EXIT_SUCCESS == sToU(tmpString, tabNumCarte);
} while (!blnSaisieOk);
sort(tabNumCarte.begin(), tabNumCarte.end()); // trie du tableau qui contient les cartes a changer
// ECHANGE des cartes de Homme
for(unsigned i=0; i < tabNumCarte.size(); i++)
jeu.pushCarte(homme.mainCarte.getCarte(tabNumCarte[i]-(5-homme.mainCarte.getNbCartes()))); // remet la carte dans le tas
for(unsigned i=0; i < tabNumCarte.size(); i++)
homme.mainCarte.addCarte(jeu.popCarte()); // tire les nouvelles cartes dans le paquet
// AFFICHAGE de la nouvelle main du joueur
sauterLigne(15);
afficheEntete();
sauterLigne(15);
cout << "\tC'est la nouvelle main de " + homme.getNom() + ":" << endl;
sauterLigne(2);
cout << homme.mainCarte;
sauterLigne(2);
cout << "\tVous avez : " + homme.mainCarte.qualite() << endl;
} // (choix == 'o') || (choix == 'O')
// MISE du joueur
unsigned miseJoueur;
do{
if (homme.getScore() > pc.getScore())
cout << "\tCombien misez-vous ? (mise min: " << miseMini << " / max: " << pc.getScore() << ") : ";
else
cout << "\tCombien misez-vous ? (mise min: " << miseMini << " / max: " << homme.getScore() << ") : ";
strcpy(tmpString, "");
cin.sync(); // Synchronisation de l'input
cin >> tmpString;
miseJoueur = atoi(tmpString); // converti en unsigned le string recupere par le cin
blnSaisieOk = (miseJoueur >= miseMini &&
intLen(miseJoueur) == strlen(tmpString) &&
(unsigned)miseJoueur <= homme.getScore() &&
(unsigned)miseJoueur <= pc.getScore());
} while (!blnSaisieOk);
//cout << "La Main de " + pc.getNom() + ":" << endl;
//cout << pc.mainCarte << endl;
// CHERCHE les cartes a changer du PC
tabNumCarte.clear(); // Vidage du deque
tabNumCarte = pc.mainCarte.cartesAChanger(); // Cherche les cartes que doit changer PC
sort(tabNumCarte.begin(), tabNumCarte.end()); // trie du tableau qui contient les cartes a changer
// ECHANGE des cartes du PC
for(unsigned i=0; i < tabNumCarte.size(); i++)
jeu.pushCarte(pc.mainCarte.getCarte(tabNumCarte[i]-(5-pc.mainCarte.getNbCartes()))); // remet la carte dans le tas
for(unsigned i=0; i < tabNumCarte.size(); i++)
pc.mainCarte.addCarte(jeu.popCarte()); // tire les nouvelle
// AFFICHAGE des deux main et comparaisons des scores
sauterLigne(8);
cout << "\tC'est la main de " + homme.getNom() + ":" << endl;
sauterLigne(2);
cout << homme.mainCarte;
sauterLigne(3);
cout << "\tC'est la main de " + pc.getNom() + ":" << endl;
sauterLigne(2);
cout << pc.mainCarte;
sauterLigne(3);
cout << endl << "\t\t\xda\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xbf" << endl
<< "\t\t\xb3" << "Comparaison des mains des deux joueurs\xb3" << endl
<< "\t\t\xc0\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xd9";
sauterLigne(4);
cout << "\t" << pc.getNom() + " a : " + pc.mainCarte.qualite() << endl;
cout << "\t" << homme.getNom() + " a : " + homme.mainCarte.qualite();
sauterLigne(3);
// DERTERMINE et Calcul les scores des joueurs
switch (homme.mainCarte.cmpWith(&pc.mainCarte)){
case -1: // pc gagne
cout << "\tc'est " << pc.getNom() << " qui a gagne" << endl;
pc.letScore(pc.getScore() + miseJoueur);
homme.letScore(homme.getScore() - miseJoueur);
break;
case 1: // homme gagne
cout << "\tc'est " << homme.getNom() << " qui a gagne" << endl;
homme.letScore(homme.getScore() + miseJoueur);
pc.letScore(pc.getScore() - miseJoueur);
break;
case 0: // match nul
cout << "\tPas de gagnant, il y a egalite !!!" << endl;
break;
}
// AFFICHAGE des scores
cout << endl << "\t\t\t\xda\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xbf" << endl
<< "\t\t\t\xb3Scores des deux joueurs\xb3" << endl
<< "\t\t\t\xc0\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xd9" << endl << endl;
cout << "\t" << pc.getNom() << " a " << pc.getScore() << " points" << endl;
cout << "\t" << homme.getNom() << " a " << homme.getScore() << " points" << endl;
if (0 == pc.getScore() || 0 == homme.getScore()){ // il y a un gagnant
sauterLigne(2);
cout << "\t\t\tPartie terminee..." << endl;
cout << ((0 == pc.getScore()) ? "\t\tJe vous ais laisse une chance !!":
"\t\tAvouez que je suis le plus fort !!");
sauterLigne(1);
cout << "\t\tAppuyez sur une touche pour quitter";
cin.sync();
cin.get();
blnRejouer = false;
} else{ // pas de gagnant
do{
cout << "\tVoulez-vous continuer la partie ? (o/n): ";
choix = ' ';
cin.sync(); // Synchronisa tion de l'input
cin >> choix;
cin.get();
} while (!(choix == 'o' || choix == 'O' ||
choix == 'n' || choix == 'N'));
blnRejouer = (choix == 'o' || choix == 'O');
} // ne veut pas continuer
} while (blnRejouer);
// FIN du jeu
sauterLigne(8);
cout << "\t\tMerci d'avoir joue a mon jeu :-)\n\t\tAppuyez sur une touche pour quitter";
sauterLigne(18);
cin.sync();
for(int i=0; i <5; i++) cout << "\x7"; // Bip Bip ...
cin.get();
cin.sync();
return EXIT_SUCCESS;
};
int sToU(char* chaine, deque<unsigned>& tab){
// prend un char* et retourne une deque de unsigned si le char* contient que des unsigned
int tmpInt = 0;
int expo = 0;
unsigned j=0;
if ((10 < strlen(chaine)) || (1 > strlen(chaine))) // trop de caracteres dans la ligne
return EXIT_FAILURE;
for(unsigned i=0; i < strlen(chaine); i++){
if (((int)chaine[i] >= 49) && ((int)chaine[i] <= 53)){ // chiffre entre 1 et 5 compris
tmpInt = (tmpInt * 10^expo) + ((int)chaine[i])%48;
expo++;
}
else if (32 == (int)chaine[i]){ // caractere espace
if ((unsigned)tmpInt > 5 || isPresent(tab, tmpInt-1)) // la carte n'existe pas ou
return EXIT_FAILURE; // la valeur est en double
tab.push_back((unsigned)tmpInt-1);
/* Reinitialisation des variables */
expo = 0;
tmpInt = 0;
} else // caractere n'est pas un chiffre ni un espace
return EXIT_FAILURE;
} // fin de tab
if ((unsigned)tmpInt > 5 || isPresent(tab, tmpInt-1)) // la carte n'existe pas
return EXIT_FAILURE; // la valeur est en double
if ((unsigned)tmpInt != 0)
tab.push_back((unsigned)tmpInt-1); // sauvegarde le dernier chiffre en traitement
return EXIT_SUCCESS;
};
bool isPresent(deque<unsigned>& tab, unsigned val){
for(unsigned i=0; i<tab.size();i++)
if (tab[i] == val) // la valeur est deja presente
return true;
return false; // la valeur n'est pas dans le deque
};
unsigned intLen(int tmpInt){
// retourne la longueur d'un integer
unsigned count = 0;
while (tmpInt > 0){
tmpInt /= 10;
count++;
}
return count;
};
// Fonctions d'affichage
void afficheEntete(){
sauterLigne(5);
cout << "\t\t\t\xda\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xbf" << endl
<< "\t\t\t\xb3\xda\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xbf\xb3" << endl
<< "\t\t\t\xb3\xb3 \xb3\xb3" << endl
<< "\t\t\t\xb3\xb3 Bienvenue au jeu de Poker \xb3\xb3" << endl
<< "\t\t\t\xb3\xb3 de Julien Hamard \xb3\xb3" << endl
<< "\t\t\t\xb3\xb3 \xb3\xb3" << endl
<< "\t\t\t\xb3\xc0\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xd9\xb3" << endl
<< "\t\t\t\xc0\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xd9" << endl;
};
void sauterLigne(unsigned nbLigne){
for(unsigned i=0; i<nbLigne; i++)
cout << endl;
};
/***************************************************************************
Cartes.h - description
-------------------
begin :
copyright : (C) 2002 by J. Hamard
email : juju.hamard@wanadoo.fr
/***************************************************************************
- *
- This program is free software; you can redistribute it and/or modify *
- it under the terms of the GNU General Public License as published by *
- the Free Software Foundation; either version 2 of the License, or *
- (at your option) any later version. *
- *
#ifndef _CARTES_H_
#define _CARTES_H_
#include <string>
using namespace std;
/****************************
class Carte{
public:
/* Constructeurs */
Carte(); /* construit une nouvelle carte aleatoirement */
Carte(const Carte&); /* constructeur de copie */
Carte(unsigned, unsigned); /* construit une nouvelle carte avec les proprietes
donnees (valeur, couleur)*/
/* Destructeurs */
~Carte(); /* detruit la carte */
/* Surdefinition */
friend ostream& operator<<(ostream&, const Carte&);
friend bool operator==(const Carte&, const Carte&);
Carte& operator=(const Carte&); /* surdefinition de l'affectation */
/* Accesseurs */
unsigned getCouleur() const; /* renvoye la couleur de la carte */
unsigned getValeur() const; /* renvoye la valeur de la carte */
char symbole() const; /* renvoye le caractere de la couleur de la carte */
string nomValeur() const; /* renvoye la valeur de la carte */
string designation() const; /* renvoye la nom de la carte */
private:
unsigned couleur;
unsigned valeur;
};
#endif
/***************************************************************************
JeuCartes.h - description
-------------------
begin :
copyright : (C) 2002 by J. Hamard
email : juju.hamard@wanadoo.fr
/***************************************************************************
- *
- This program is free software; you can redistribute it and/or modify *
- it under the terms of the GNU General Public License as published by *
- the Free Software Foundation; either version 2 of the License, or *
- (at your option) any later version. *
- *
/* Le jeu de carte est composé de 52 cartes */
#ifndef _JEU_CARTES_H_
#define _JEU_CARTES_H_
#include "cartes.h"
#include <deque>
using namespace std;
/*******************************
class JeuCarte{
public:
/* Constructeurs */
JeuCarte();
/* Destructeur */
~JeuCarte();
/* Surdefinition */
friend ostream& operator<<(ostream&, const JeuCarte&);
/* Accesseurs */
int melanger(); /* Melange le jeu de carte aleatoirement */
Carte popCarte(); /* Donne la premiere carte */
int pushCarte(Carte); /* push_back -> ajoute la Carte a la fin du paquet */
private:
deque<Carte> jeuCarte;
deque<Carte>::iterator IterJeuCarte;
}; // JeuCarte
#endif
/***************************************************************************
Joueur.h - description
-------------------
begin :
copyright : (C) 2002 by J. Hamard
email : juju.hamard@wanadoo.fr
/***************************************************************************
- *
- This program is free software; you can redistribute it and/or modify *
- it under the terms of the GNU General Public License as published by *
- the Free Software Foundation; either version 2 of the License, or *
- (at your option) any later version. *
- *
#ifndef _JOUEUR_H_
#define _JOUEUR_H_
#include "jeuCartes.h"
#include "mainCartes.h"
#include <string>
using namespace std;
/*****************************
class Joueur{
public:
/* Constructeurs */
Joueur();
Joueur(std::string, int);
/* Destructeur */
~Joueur();
/* Surdefinition */
friend ostream& operator<<(ostream&, const Joueur&);
/* Accesseurs */
void init(string, int);
string getNom();
void letScore(unsigned);
unsigned getScore();
Main mainCarte;
private:
string nom;
unsigned score;
};
#endif
/***************************************************************************
mainCartes.h - description
-------------------
begin :
copyright : (C) 2002 by J. Hamard
email : juju.hamard@wanadoo.fr
/***************************************************************************
- *
- This program is free software; you can redistribute it and/or modify *
- it under the terms of the GNU General Public License as published by *
- the Free Software Foundation; either version 2 of the License, or *
- (at your option) any later version. *
- *
/* La Main est composee de 5 cartes */
#ifndef _MAIN_CARTES_H_
#define _MAIN_CARTES_H_
#include "cartes.h"
#include <vector>
#include <deque>
#include <string>
using namespace std;
/***************************
class Main{
public:
/* Constructeurs */
Main();
/* Destructeur */
~Main();
/* Surdefinition */
friend ostream& operator<<(ostream&, Main&);
/* Accesseurs */
Carte getCarte(unsigned); /* Renvoie la carte correspondante au numero de carte 0..4 (la retir donc de la main !!)*/
unsigned getScore(); /* Renvoie le score de la main */
unsigned getNbCartes(); /* Renvoie le nombre de cartes dans la main */
int addCarte(Carte); /* Ajoute la carte a la main */
int delCarte(unsigned); /* Retir la carte de la main */
int trier(); /* trie la main dans l'ordre croissant des valeurs */
int cmpWith(Main*); /* Compare la main courante avec la main en parametre */
string qualite(); /* retourne la qualite de la main */
deque<unsigned> cartesAChanger(); /* Retourne les cartes qui sont bonnes a changer */
private:
vector<Carte> mainCarte;
vector<Carte>::iterator IterMainCarte;
unsigned score; /* valeur en points de la main */
unsigned nbCartes; /* nombre de cartes de la main 0..4 */
unsigned paire; /* nombre de paires de la main */
unsigned valPaire[3]; /* */
int valeursOk(unsigned, unsigned);
bool isSuite(); /* true si la main est une suite */
bool isCouleur(); /* true si la main est une couleur */
bool peutFaireSuite(unsigned); /* true si il suffi de changer une seule carte pour faire une suite */
void compterPaires(); /* 1ere paire, 2eme paire, triple */
bool isPresent(Carte&); /* true si la carte est presente dans la main */
bool isPresent(Carte&, unsigned&); /* idem + retourne la position de la carte */
}; // Main
#endif
Conclusion :
Dés que j'ai un peut de temps je corrige des petits problemes...
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.