Poker mode console (gcc + windows)

Soyez le premier à donner votre avis sur cette source.

Vue 5 831 fois - Téléchargée 587 fois

Description

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; /****************
  • Function Main *
                                • /
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 ******
                                                        • /
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 ******
                                                                • /
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 ******
                                                          • /
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 ******
                                                      • /
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...

Codes Sources

A voir également

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.