Objet jeu de carte

tidianetandjigora Messages postés 3 Date d'inscription   Statut Membre Dernière intervention   -  
Drerrawyn Messages postés 82 Date d'inscription   Statut Membre Dernière intervention   -
Bonjour, dans le cadre d'un BTS] sio on nous a demandé de réaliser un algorithme d'un black jack. Étant orienter réseau j'ai un peu de mal à le réaliser , j'ai besoin de quelque conseil pour pouvoir le réaliser.(les boucles à utiliser ,fonctions)
Je vous remercie
A voir également:

1 réponse

Réponse 1 / 1
Drerrawyn Messages postés 82 Date d'inscription   Statut Membre Dernière intervention   6
 
J'ai eu un projet personnel de ce type, personellement, j'ai créé une classe Carte, et une classe paquet, qui contient un tableau de cartes.
Une carte était définie par une couleur, une valeur et un propriétaire, ainsi on a un objet paquet de carte qui ressemble à un paquet physique, à savoir un nombre de cartes réparties en plusieurs propriétaires.
Je peux fournir le code de mes objets, étant donné que l'ai fourni dans un autre fil:

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;
}
0