Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd Logo
Upload

Welcome to Scribd!

  • 10 views

    Poker Game

    Uploaded by

    justinisaac.ngomoakoung
    Zk2jegt

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd

    Poker Game

    Uploaded by

    justinisaac.ngomoakoung
    10 views5 pages
    Zk2jegt

    Original Title

    poker game

    Copyright

    © © All Rights Reserved

    Available Formats

    PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    Zk2jegt

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    10 views5 pages

    Poker Game

    Uploaded by

    justinisaac.ngomoakoung
    Zk2jegt

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    You are on page 1of 5

    ​Voici le projet C++ avec les classes `Card`, `Player` et `Game` séparées dans des fichiers `.h` et `.

    cpp` :

    **Card.h**
    ```cpp
    #ifndef CARD_H
    #define CARD_H

    #include <string>

    class Card {
    private:
    std::string suit;
    int rank;

    public:
    Card(std::string suit, int rank);
    std::string getSuit() const;
    int getRank() const;
    void print() const;
    };

    #endif // CARD_H
    ```

    **Card.cpp**
    ```cpp
    #include "Card.h"
    #include <iostream>

    Card::Card(std::string suit, int rank) : suit(suit), rank(rank) {}

    std::string Card::getSuit() const {


    return suit;
    }

    int Card::getRank() const {


    return rank;
    }

    void Card::print() const {


    std::cout << rank << " of " << suit << std::endl;
    }
    ```

    **Player.h**
    ```cpp
    #ifndef PLAYER_H
    #define PLAYER_H

    #include <string>
    #include <vector>
    #include "Card.h"

    class Player {
    private:
    std::string name;
    std::vector<Card> hand;

    public:
    Player(std::string name);
    void addCard(const Card& card);
    void printHand() const;
    std::vector<Card>& getHand();
    };

    #endif // PLAYER_H
    ```

    **Player.cpp**
    ```cpp
    #include "Player.h"
    #include <iostream>

    Player::Player(std::string name) : name(name) {}

    void Player::addCard(const Card& card) {


    hand.push_back(card);
    }

    void Player::printHand() const {


    std::cout << name << "'s hand: " << std::endl;
    for (const auto& card : hand) {
    card.print();
    }
    }

    std::vector<Card>& Player::getHand() {
    return hand;
    }
    ```
    **Game.h**
    ```cpp
    #ifndef GAME_H
    #define GAME_H

    #include <vector>
    #include "Card.h"
    #include "Player.h"

    class Game {
    private:
    std::vector<Card> deck;
    std::vector<Player> players;
    int numPlayers;

    public:
    Game(int numPlayers);
    void play();
    };

    #endif // GAME_H
    ```

    **Game.cpp**
    ```cpp
    #include "Game.h"
    #include <algorithm>
    #include <random>
    #include <chrono>

    Game::Game(int numPlayers) : numPlayers(numPlayers) {


    // Créer le jeu de cartes
    std::vector<std::string> suits = {"Hearts", "Diamonds", "Clubs", "Spades"};
    for (const auto& suit : suits) {
    for (int rank = 1; rank <= 13; ++rank) {
    deck.emplace_back(suit, rank);
    }
    }

    // Mélanger le jeu de cartes


    auto seed = std::chrono::system_clock::now().time_since_epoch().count();
    std::shuffle(deck.begin(), deck.end(), std::default_random_engine(seed));

    // Créer les joueurs


    for (int i = 0; i < numPlayers; ++i) {
    std::string name = "Player " + std::to_string(i + 1);
    players.emplace_back(name);
    }

    // Distribuer les cartes aux joueurs


    for (int i = 0; i < 5; ++i) {
    for (auto& player : players) {
    player.addCard(deck.back());
    deck.pop_back();
    }
    }
    }

    void Game::play() {
    while (true) {
    for (auto& player : players) {
    player.printHand();
    std::cout << "Voulez-vous jouer une carte ? (o/n) ";
    char choice;
    std::cin >> choice;
    if (choice == 'o') {
    // Jouer une carte
    std::cout << "Quelle carte voulez-vous jouer ? ";
    int index;
    std::cin >> index;
    if (index >= 0 && index < player.getHand().size()) {
    Card card = player.getHand()[index];
    player.getHand().erase(player.getHand().begin() + index);
    std::cout << "Vous avez joué la carte : ";
    card.print();
    } else {
    std::cout << "Index invalide." << std::endl;
    }
    }
    }
    }
    }
    ```

    **main.cpp**
    ```cpp
    #include "Game.h"

    int main() {
    Game game(4);
    game.play();
    return 0;
    }
    ```

    Dans ce projet, chaque classe (`Card`, `Player` et `Game`) a été séparée dans des fichiers `.h` et `.cpp`
    distincts. Le fichier `main.cpp` contient la fonction `main()` qui crée une instance de la classe `Game` et
    lance la partie.

    Cette structure de projet facilite la maintenance et la réutilisation du code, car chaque classe est encapsulée
    dans ses propres fichiers et peut être modifiée ou remplacée indépendamment des autres.

    You might also like