Jeu de carte

Question

Bonsoir,

Je réalise actuellement pour un TP un jeu de bataille en C++.

Je rencontre un léger soucis sur lequel je n'arrive pas à avancer.. j'ai l'algorithme dans ma tête, mais impossible de le coder...

Le principe est simple, je dois coder une méthode qui me génère 52 cartes dans un ordre aléatoire. J'arrive à générer 52 cartes aléatoire, mais je rencontre plusieurs doublons biensur puisque il me génère ce que je lui demande hein...

void PaquetDeCarte::creerPaquetMelange(std::string TypeDeJeu)
{

    int taille = this->paquet.size();
    for(unsigned i = 0; i < taille; i++)
    {
        this->paquet.pop_back();
    }

    if (TypeDeJeu == "Regle1")
    {
        for(unsigned int n=0; n<52; n++)
        {
            int couleur = rand()%4 + 1;
            if (couleur == 3) couleur = 11;
            if (couleur == 4) couleur = 12;
            int valeur = rand()%13 + 2;
            ICarte* carte1 = new CarteRegle1((ACarte::Valeur) valeur,(ACarte::Couleur) couleur);
            this->paquet.push_back(carte1);
            
           }

}

}

Ce que je voudrais faire,

Je parcours mon tableau paquet.. si la carte est déjà présente dans le paquet, je ne l'ajoute pas. Si elle n'est pas présente, je l'ajoute...

Mais comment le coder, j'y arrive vraiment pas...

merci bien pour vos réponses,

Cordialement.

Utilisateur anonyme · Answer

Salut,

Tout d'abord, je ne connais pas le type de

paquet

, mais tu peux je pense remplacer

int taille = this->paquet.size();
for(unsigned i = 0; i < taille; i++)
{
    this->paquet.pop_back();
}

par

paquet.clear();

Ensuite, il y a plus simple algorithmiquement, à savoir faire comme dans la réalité, c'est-à-dire prendre un paquet et le mélanger :

vector<Carte> paquet;

void init()
{
        // Création paquet
	vector<Carte> paquetNeuf;
	for(Couleur couleur = 1; couleur <= 4; couleur++)
	{
		for(Valeur valeur = 1; valeur <= 13; valeur++)
		{
			Carte carte(couleur,valeur);
			paquetNeuf.push_back(carte);
		}
	}

	// Mélange paquet
	while(!paquetNeuf.empty())
	{
		// Prendre une carte au hasard
		int positionCarte = rand() % paquetNeuf.size();
		// L'ajouter au paquet final
		paquet.push_back(paquetNeuf[positionCarte]);
		// L'enlever du paquet initial
		paquetNeuf.erase(paquet.begin()+positionCarte);
	}
}

Drerrawyn · Answer

Effectivement, j'ai aussi fait la méthode de générer un paquet puis le mélanger dans le jeu que j'avais codé, par ailleurs j'ai toujours les sources que je partage:

Deck.h

#ifndef DECK_H_INCLUDED
#define DECK_H_INCLUDED

#include "Card.h"

class Deck {
    public:
        Deck();
        ~Deck();

        void    randomize();
        bool    pioche(int joueur);

        void    printDeck();
        void    printMain(int joueur);

    private:
        Card    m_packet[52];
};

void changeValeur(Card *tableau, int array_size, int cell1, int cell2);

#endif // DECK_H_INCLUDED

Deck.cpp

#include "Deck.h"
#include <iostream>
#include <sstream>  // Pour la conversion int to string
#include <cstdlib>
#include <ctime>
#include <map>

Deck::Deck() {
    int k = 0;
    for(int i = 0; i<4;i++)
        for(int j = 1; j<=13; j++) {
            m_packet[k].defineCard(i, j, 0);
            k++;
        }
}

Deck::~Deck() {

}

void Deck::randomize() {
    srand(time(NULL));
    for(int i = 0; i < 52; i++)
        changeValeur(m_packet, 52, i, rand()%52);
}

bool Deck::pioche(int joueur) {
    for(int i = 0; i<52;i++)
        if(!m_packet[i].getOwner()) {
            m_packet[i].setOwner(joueur);
            return true;
        }
    return false;
}

void Deck::printDeck() {
    for(int i = 0; i<52; i++)
        std::cout << i << ":\t" << m_packet[i].getValeur() << "\t" << m_packet[i].getCouleur() << "\t" << m_packet[i].getOwner() << std::endl;
}

void Deck::printMain(int joueur) {
    for(int i = 0; i<52; i++)
        if(m_packet[i].getOwner() == joueur) {
            std::string couleur;
            switch(m_packet[i].getCouleur()) {
                case PIQUE:
                    couleur = 6;        // 6 <=> pique
                    break;
                case TREFLE:
                    couleur = 5;        // 5 <=> trefle
                    break;
                case COEUR:
                    couleur = 3;        // 3 <=> coeur
                    break;
                case CARREAU:
                    couleur = 4;        // 4 <=> carreau
                    break;
                default:
                    couleur = "multicolore";
                    break;
            }
            std::string valeur;
            switch(m_packet[i].getValeur()) {
                case VALET:
                    valeur = "V";
                    break;
                case DAME:
                    valeur = "D";
                    break;
                case ROI:
                    valeur = "R";
                    break;
                default:
                    std::stringstream out;              // Conversion du int en string
                    out << m_packet[i].getValeur();     // Conversion du int en string
                    valeur = out.str();                 // Conversion du int en string
                    break;
            }
            std::cout << couleur << " " << valeur << std::endl;
        }
}

void changeValeur(Card *tableau, int array_size, int cell1, int cell2) {
    Card temp = tableau[cell1];
    tableau[cell1] = tableau[cell2];
    tableau[cell2] = temp;
}

Card.h

#ifndef CARD_H_INCLUDED
#define CARD_H_INCLUDED

#define PIQUE   0
#define TREFLE  1
#define COEUR   2
#define CARREAU 3

#define VALET   11
#define DAME    12
#define ROI     13

#define PUBLIC  255

class Card {
    public:
        Card();
        Card(int couleur, int valeur);
        Card(int couleur, int valeur, int owner);
        ~Card();

        void    defineCard(int couleur, int valeur);
        void    defineCard(int couleur, int valeur, int owner);

        int     getOwner();
        int     getValeur();
        int     getCouleur();
        void    setOwner(int owner);

    private:
        int     m_couleur;
        int     m_valeur;
        int     m_owner;        // 0 = pas de propriétaire
};

void changeValeur(int *tableau, int array_size, int cell1, int cell2);

#endif // CARD_H_INCLUDED

Card.cpp

#include "Card.h"

Card::Card() {
    m_couleur = 0;
    m_valeur = 1;
    m_owner = 0;
}

Card::Card(int couleur, int valeur) {
    m_couleur = couleur;
    m_valeur = valeur;
    m_owner = 0;
}

Card::Card(int couleur, int valeur, int owner) {
    m_couleur = couleur;
    m_valeur = valeur;
    m_owner = owner;
}

Card::~Card() {

}

void Card::defineCard(int couleur, int valeur) {
    m_couleur = couleur;
    m_valeur = valeur;
}

void Card::defineCard(int couleur, int valeur, int owner) {
    m_couleur = couleur;
    m_valeur = valeur;
    m_owner = owner;
}


int Card::getOwner() {
    return m_owner;
}

int Card::getValeur() {
    return m_valeur;
}

int Card::getCouleur() {
    return m_couleur;
}

void Card::setOwner(int owner) {
    m_owner = owner;
}

Have fun si tu veux analyser l'algo ^^

Jeu de carte

2 réponses

Discussions similaires

Newsletters