Aide jeu de poker

Signaler
-
Messages postés
3829
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
8 janvier 2021
-
bonjour, je doit faire une jeu de poker en c++ mais j'ai un probleme pour la fonction de la quinte mais aussi pour les fonction qui vont me donner un full (brelan+paire).

#include 
#include <ctime>
#include <string>
using namespace std ;


string couleurs[4] = {"trefle","carreau","pique","coeur"};
string faces[8] = {"sept","huit","neuf","dix","valet","dame","roi","as"};
struct Carte
{
string couleur ;
string face ;
} ;
typedef Carte Jeu[32];

void jeu_de_carte(Jeu& jeu)
{
int x = 0;
for (int i=0;i<4;i++)
{
for(int j=0;j<8;j++)
{
jeu[x].couleur= couleurs[i];
jeu[x].face = faces[j];
x++;
}
}
}
void melangerJDC(Jeu& jeu)
{
int i, index1, index2;
for (i=0;i<50;i++)
{
index1=(rand()%32);
index2= (rand()%32);
Carte temp = jeu [index1] ;
jeu [index1] = jeu [index2] ;
jeu [index2] = temp;
}
}
void distribuer(Jeu& jeu)
{
int i=0;
cout << "votre main"<< endl;
cout << endl;
for (int i=0;i<5;i++)
cout << jeu[i].face << " de " << jeu[i].couleur <<endl;
cout<<endl;
}

void paires(Jeu& jeu)
{
bool unepaire=false,deuxpaires=false;
int compPaire=0;
for (int i=0;i<5;i++)
{
for (int j=0;j<5;j++)
{
if (jeu[i].face==jeu[j].face && i!=j)
{
compPaire++;
}
}
}
if(compPaire==2)
{
unepaire=true;
cout<<"Il y a une paire."<<endl;
}
else
{
if(compPaire==4)
{
deuxpaires=true;
cout<<"Il y a deux paires."<<endl;
}
else
{
cout<<"Il n'y a pas de paires."<<endl;
}
}	
}
void couleur(Jeu& jeu)
{
bool coul=false;
int compCouleur =0;
cout << "fonction couleur" << endl;
for (int i=0;i<5;i++)
{
for (int j=0;j<5;j++)
{
if (jeu[i].couleur==jeu[j].couleur && i!=j)
{
compCouleur++;
}
}
}
if (compCouleur == 8)
{
coul=true;
cout << "Vous avez une couleur" << endl;
}
}
void quinte(Jeu& jeu)
{

}
int main()
{
srand(( unsigned) time(0)) ;
Jeu jeu;
jeu_de_carte(jeu);
melangerJDC(jeu);
distribuer(jeu);
couleur(jeu);
quinte(jeu);
paires(jeu);

}



donc pour ma fonction avec la quinte j'avais penser à sa :

int k=0,l=k+1;

while((1+(jeu[k].face)==jeu[l].face)&& k<5)
    {
        k++;
        l=k+1;
    }
    if (k==4)
    {
        cout << " vous avez une quinte " << endl;
    }


mais sa me sort un erreur incompréhensible. et j'ai pas trop d'idée pour faire sa d'une autre façon.
A voir également:

9 réponses

Messages postés
1137
Date d'inscription
lundi 17 novembre 2003
Statut
Membre
Dernière intervention
23 janvier 2016
21
Salut,

On pourrait rajouter 2 tableaux
1 pour la correspondance numérique des faces
1 autre pour la main en cours (les 5 cartes données dans "distribuer")

On ajoute aussi la face numérique dans la structure.

Ensuite on applique un tri asendant sur la main (qsort)
et on a plus qu'à vérifier que les cartes se suivent, c'est une suite.
Si en plus elles sont de la même couleur, c'est une suite couleur.

struct Carte
{
    std::string couleur;
    std::string face;
    int nFace; // ajouté ICI
};

// Les faces
int nFaces[8] = {7,8,9,10,11,12,13,14};
// La main
int maQuinte[5] = {-1,-1,-1,-1,-1};

// La fonction de tri
static int compareINT_ASC(const void* v1, const void* v2)
{
return( *(int*)v1 - *(int*)v2 );
}

// Dans l'init on rajoute la face numérique en plus de celle en chaine
void jeu_de_carte(Jeu& jeu)
{
int x = 0;
for (int i=0;i<4;i++)
{
for(int j=0;j<8;j++)
{
jeu[x].couleur = couleurs[i];
jeu[x].face = faces[j];
jeu[x].nFace = j;  // ajouté ICI
x++;
}
}
}

// on ajoute l'affectation de la main et le tri 
void distribuer(Jeu& jeu)
{
int i=0;
std::cout << "votre main"<< std::endl;
std::cout << std::endl;
for (int i=0;i<5;i++)
{
maQuinte[i] = jeu[i].nFace; // ajouté ICI
std::cout << jeu[i].face << " de " << jeu[i].couleur <<  std::endl;
}
std::cout << std::endl;

// tri pour recherche quinte
qsort(maQuinte, 5, sizeof(maQuinte[0]), compareINT_ASC);

        // Affiche le tri
std::cout << "apres trie : "<< std::endl << std::endl;
for (int i=0;i<5;i++)
std::cout << "\t\tnFace = " << nFaces[maQuinte[i]] <<  std::endl;
}

// Recherche quinte + quinte couleur
void quinte(Jeu& jeu)
{
bool bSuiteCouleur = true;
for (int i=0; i<5-1; i++)
{
if( maQuinte[i] != maQuinte[i+1]-1 )
{
std::cout << "\tpas de quinte !"  <<  std::endl;
return;
}
else if( jeu[i].couleur != jeu[i+1].couleur )
bSuiteCouleur = false;
}

std::cout << std::endl << "\tQUINTE !!"  << 
(bSuiteCouleur ? " DE LA MEME COULEUR !!!" : "") <<  std::endl;
}


si tu veux tester la quinte, rajoutes en fin de fonction melanger :

void melangerJDC(Jeu& jeu)
{
    // code random...
    // (...)

    for (i=0;i<5;i++) // FORCE QUINTE MEME COULEUR
    {
  jeu[i].face = faces[i];
  jeu[i].nFace = i;
  jeu[i].couleur = couleurs[0];
  // change une seule couleur
  //if(i==4) jeu[i].couleur = couleurs[1];	
    }
}



bye...
ok merci beaucouop sa me donne du boulot pour apprendre/comprendre ce que tu viens de me donner, merci beaucoup.
je comprend pas vraiment la fonction de tri:
static int compareINT_ASC(const void* v1, const void* v2)
{
return( *(int*)v1 - *(int*)v2 );
}

le statis j'ai regarder sur un cour mais sa m'aider pas vraiment.

et est ce normal que tu n'est pas réutilisé mon typedef ?
Tu fais le tri pour la recherche de quinte dans la fonction pour distribuer ?
Pourquoi ne pas faire sa dans la fonction de la recherche de la quinte ?
Messages postés
1137
Date d'inscription
lundi 17 novembre 2003
Statut
Membre
Dernière intervention
23 janvier 2016
21
Salut,

oui, j'ai utilisé ton typedef, mais je ne l'ai pas reporté dans le code exemple (pour pas reposter tout ton code mais seulement mes ajouts)

Je t'ai juste donné une piste, à toi de l'arranger comme tu veux.
Tu peux bien sur faire le tri quant tu veux.
Mais si plusieurs fonctions différentes utilisent le tri, alors il faudra le refaire à chaque fois (optimisation)

La fonction qsort du standard C demande une fonction "utilisateur" de prototype :
int (__cdecl* compare)(const void* elem1, const void* elem2);

Du fait que les paramètres ne sont pas fortement typés, il faut caster puis déréférencer le pointeur pour atteindre la variable pointée de type int.
*(int*)v1
de droite à gauche : transforme v1 en pointeur sur int puis demande la valeur pointée.

le static spécifie ici que la fonction est globale et appartient au seul module dans lequel elle est déclarée, (un peu l'inverse de extern). On ne pourra pas appeler cette fonction depuis l'exterieur de ce fichier.
static appliqué à une variable dans un bloc permet de garder sa valeur entre chaque appels.
static en c++ "objet" à d'autres utilités comme le partage de mémoire entre plusieurs instances d'un objet.

bye...
wouah...
heu j'ai l'impression que tu viens de parler en chinois, je vais me renseigner sur tout sa et si j'ai un probleme ba je te demanderai. merci beaucoup
Messages postés
3829
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
8 janvier 2021
114
La fonction qsort du standard C

Explication tout à fait correcte de yann_lo_san. Un petit détail tout de même: En c++, on évite ce genre de chose et on utilise tout simplement std::sort (qui fonctionne aussi sur des array à la C). Ex:
std::sort(maQuinte, maQuinte + 5); // du début (maQuinte + 0) à la fin du tableau (maQuinte + 5)


Du fait que les paramètres ne sont pas fortement typés, il faut caster puis déréférencer le pointeur pour atteindre la variable pointée de type int.
*(int*)v1

En C++, on évite les "C cast" au profit de: reinterpret_cast, static_cast et dynamic_cast. Ici un reinterpret_cast aurait été judicieux.

le static spécifie ici que la fonction est globale et appartient au seul module dans lequel elle est déclarée, (un peu l'inverse de extern). On ne pourra pas appeler cette fonction depuis l'exterieur de ce fichier.

Attention, en C++ l'utilisation du mot clé "static" pour ce genre de comportement est déprécié. Lorsque l'on veut qu'une fonction n'appartienne qu'au module, on utilise un namespace anonyme.
Ex:
static void func1()
{
}

static void func2()
{
}

Devrait être:
namespace
{
  void func1()
  {
  }

  void func2()
  {
  }
} // namespace



@Razgrizz: Je te conseille de réutiliser la classe "CardDeck" pour ce projet, comme vu ici: http://www.cppfrance.com/forum/sujet-BLACK-JACK-DEBUTANT-CPLUSPLUS_1622449.aspx

________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question
Messages postés
1137
Date d'inscription
lundi 17 novembre 2003
Statut
Membre
Dernière intervention
23 janvier 2016
21
Salut,

le fait est que le code d'otigine ne ressemble en rien à du c++ :
struct et typedef
variables globales
fonctions en dehors de toutes classes
aucun objet ect...

du coup il m'a semblé plus judiceux d'orienter l'exemple vers du C.

Mais il est vrai que ce melange de concept C et C++ non "objet" est assez terrible.

bye...
Messages postés
3829
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
8 janvier 2021
114
le fait est que le code d'otigine ne ressemble en rien à du c++ :

C'est vrai qu'il exploite peu les spécifités du C++, et que son code ressemble à du C.

struct et typedef

En C++ on utilise beaucoup struct et typedef. Struct est une classe publique, et typedef est très utile quand on crée des classes avec "iterator", quand on fait de l'héritage, etc...

variables globales

En C++ aussi il y en a (mauvaise pratique commune aux deux langages).


fonctions en dehors de toutes classes
aucun objet ect...
[...]
il est vrai que ce melange de concept C et C++ non "objet" est assez terrible.

Attention le C++ n'est pas un langage objet. C'est un langage multi-paradigme, où l'objet est loin d'être la fonctionnalité la plus importante. Il est possible de faire du C++ sans aucun objet (on peut très bien faire du fonctionnel avec des lambda, de la meta-programmation, ou de la programmation comme en C tout en profitant du RAII). Ne pas faire d'objet en C++ n'est ni un défi spécifique, ni une mauvaise pratique. C'est une utilisation courante.

Ce qui met surtout la puce à l'oreille c'est:
- La section où il a posté (ok, c'est pas toujours bien rempli)
- Les includes
- Les std::cout
- Le & dans une signature de fonction (impossible en C)

Néanmoins, je pinaille, mais je suis tout à fait d'accord avec ce que tu dis :)
J'ai moi aussi cru que c'était du code C.


________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question