Scribd Logo
Upload

Welcome to Scribd!

  • 27 views

    Main Cppas

    Uploaded by

    AMEERO THE HERO
    The document defines classes and functions for a card game including: - An enum to represent player teams (Red, Green, Blue) - Functions to generate a deck of cards and deal cards to players - A Player class to represent players with a name, team, deck and other attributes - Functions to display the game board, player decks, and possible moves - A function to place a token on the board if a card is valid and not already placed - A main function to initialize the game and call the play function to run game turns

    Copyright:

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

    Main Cppas

    Uploaded by

    AMEERO THE HERO
    27 views5 pages
    The document defines classes and functions for a card game including: - An enum to represent player teams (Red, Green, Blue) - Functions to generate a deck of cards and deal cards to players - A Player class to represent players with a name, team, deck and other attributes - Functions to display the game board, player decks, and possible moves - A function to place a token on the board if a card is valid and not already placed - A main function to initialize the game and call the play function to run game turns

    Original Description:

    sss

    Original Title

    main.cppas

    Copyright

    © © All Rights Reserved

    Available Formats

    TXT, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    The document defines classes and functions for a card game including: - An enum to represent player teams (Red, Green, Blue) - Functions to generate a deck of cards and deal cards to players - A Player class to represent players with a name, team, deck and other attributes - Functions to display the game board, player decks, and possible moves - A function to place a token on the board if a card is valid and not already placed - A main function to initialize the game and call the play function to run game turns

    Copyright:

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

    Main Cppas

    Uploaded by

    AMEERO THE HERO
    The document defines classes and functions for a card game including: - An enum to represent player teams (Red, Green, Blue) - Functions to generate a deck of cards and deal cards to players - A Player class to represent players with a name, team, deck and other attributes - Functions to display the game board, player decks, and possible moves - A function to place a token on the board if a card is valid and not already placed - A main function to initialize the game and call the play function to run game turns

    Copyright:

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

    #include <iostream>

    #include <iomanip>
    #include <vector>

    enum Team {NONE, RED, GREEN, BLUE};

    std::vector<std::string> generateDeck() {
    std::vector<std::string> cards;
    std::vector<std::string> suits = {"H", "C", "S", "D"};
    std::vector<std::string> ranks = {"2", "3", "4", "5", "6", "7", "8", "9", "10",
    "J", "Q", "K", "A"};

    for (const auto& suit : suits) {


    for (const auto& rank : ranks) {
    cards.push_back(suit+rank);
    }
    }
    return cards;

    static std::vector<std::string> cards = generateDeck();

    class Player {
    public:
    Player(std::string name, Team team, int deckSize)
    : name(name), team(team), deckSize(deckSize) {
    std::vector<std::string> deck;
    };

    std::string getName() const {


    return name;
    }

    Team getTeam() const {


    return team;
    }

    std::vector<std::string> getDeck() {
    return deck;
    }
    int getDeckSize() {
    return deckSize;
    }
    void displayPlayerDeck() {
    for (int i = 0; i< deckSize; i++) {
    std::cout << "decksize:"<< i << std::endl;
    std::cout << deck.at(i) << ", ";
    }
    std::cout << std::endl;
    }

    void dealCards() {
    while (deck.size()< deckSize) {
    int cardIndex = (rand() % 52);
    std::string selectedCard = cards.at(cardIndex);
    deck.push_back(selectedCard);
    cards.erase(cards.begin() + cardIndex);
    std::cout << "Delt " << selectedCard << "." << std::endl;
    }
    }
    private:
    const std::string name;
    const Team team;
    const int deckSize;
    std::vector<std::string> deck;

    };

    void displayTextUI(std::string gameBoard[10][10], std::vector<std::pair<Team,


    std::pair<int, int>>>& tileMap) {
    std::cout << "\n===========================================\n";
    for (int i = 0; i < 10; i++) {
    std::cout << "|";
    for (int j = 0; j < 10; j++) {
    std::string card = gameBoard[i][j];
    std::string color = "\033[0m"; // Default Color

    for (const auto& map : tileMap) {


    int x = map.second.first;
    int y = map.second.second;
    if (i == y && j == x) {
    Team team = map.first;
    if (team == Team::RED) {
    color = "\033[31m"; // Red color
    }
    else if (team == Team::GREEN) {
    color = "\033[32m"; // Green color
    }
    else if (team == Team::BLUE) {
    color = "\033[34m"; // Blue color
    }
    break;
    }
    }

    std::cout << color << std::setw(3) << card << "\033[0m|";


    }
    std::cout << "\n-----------------------------------------\n";
    }
    }

    std::string teamToString(Team team) {


    std::string stringTeam = team == Team::RED ? "RED" : team == Team::BLUE ?
    "BLUE" : "GREEN";
    return stringTeam;

    bool isAdjacent(std::vector<std::pair<Team, std::pair<int, int>>> tileMap,


    std::pair<int, int> pos) {
    std::pair<int, int> directions[8] = { {1, 0}, {1, 1}, {0, 1}, {-1, 0}, {-1, -
    1}, {0, -1}, {1, -1}, {-1, 1} };
    for (const auto& offset : directions) {
    for (const auto& tile : tileMap) {
    std::pair<int, int> tileCoords = tile.second;
    if (tileCoords.first == pos.first + offset.first && tileCoords.second
    == pos.second + offset.second) {
    return 1;
    }
    }
    }
    return 0;
    }

    std::vector<std::pair<int, int>> getPossibleMoves(std::string gameBoard[10][10],


    std::vector<std::pair<Team, std::pair<int, int>>> tileMap) {
    std::vector<std::pair<int, int>> possibleMoves;
    for (int i = 0; i < 10; i++) {
    for (int j = 0; j < 10; j++) {
    for (const auto& tile : tileMap) {
    if (i == tile.second.first && j == tile.second.second) {
    std::pair<int, int> pos = std::make_pair(i, j);
    if (isAdjacent(tileMap, pos)) {
    possibleMoves.insert(possibleMoves.begin(), pos);
    }
    else {
    possibleMoves.push_back(std::make_pair(i, j));
    }
    }
    }
    }
    }
    return possibleMoves;
    }

    bool placeToken(std::string gameBoard[10][10], std::vector<std::pair<Team,


    std::pair<int, int>>> &tileMap, std::pair<int, int> pos, Player player) {
    std::string card = gameBoard[pos.first][pos.second];
    bool inDeck = false;
    std::vector<std::string > playerDeck = player.getDeck();
    for (int i = 0; i < playerDeck.size(); i++) {
    if (card == playerDeck[i]) {
    inDeck = true;
    break;
    }
    }
    if (!inDeck) {
    std::cout << "Card not Owned." << std::endl;
    return 0;
    }

    for (const auto& tile : tileMap) {


    std::pair<int, int> tileCoords = std::make_pair(tile.second.first,
    tile.second.second);
    if (tileCoords.first == pos.first && tileCoords.second == pos.second) { //
    Check if tile is already place there
    return 0;
    }
    }

    tileMap.push_back(std::make_pair(player.getTeam(), pos));
    return 1;
    }
    void play(std::string gameBoard[10][10], std::vector<Player> players,
    std::vector<std::pair<Team, std::pair<int, int>>> &tileMap) {
    int turnValue = 0;
    int rounds = 8;

    for (Player player : players) {


    player.dealCards();
    }
    for (int i = 0; i < rounds; i++) {

    //Player turn variables


    Player player = players.at(turnValue);
    std::string playerString = player.getName();
    Team team = player.getTeam();

    //Visual Display
    std::cout << playerString << "'s turn | TEAM: " << teamToString(team) <<
    std::endl;
    std::cout << player.getDeck().size();
    player.displayPlayerDeck();
    displayTextUI(gameBoard, tileMap);

    //Player turn
    bool placed = false;
    while (!placed) {
    std::pair<int, int> pos;
    std::cout << "POS:";
    std::cin >> pos.first >> pos.second;
    placed = placeToken(gameBoard, tileMap, pos, player);
    }

    turnValue = (turnValue + 1) % players.size();

    }
    }

    int main() {
    std::string gameBoard[10][10] = {
    {"F1", "JS", "9S", "KH", "9D", "QC", "9H", "KC", "JD", "F2"},
    {"3C", "2H", "4H", "6D", "8S", "KS", "2S", "6C", "10C", "2D"},
    {"5C", "QD", "10D", "QS", "JC", "2C", "4D", "8C", "AC", "4S"},
    {"3D", "AH", "3H", "7D", "9S", "AS", "6S", "10S", "KD", "6H"},
    {"5D", "JH", "5H", "7S", "JS", "4C", "8D", "QH", "KC", "8H"},
    {"3S", "AD", "7H", "10H", "QS", "6D", "10D", "KH", "AC", "10H"},
    {"5S", "KS", "5C", "7C", "2H", "8H", "JH", "9C", "2S", "QH"},
    {"7S", "AS", "3C", "9C", "4H", "10S", "KD", "JC", "4C", "KH"},
    {"6S", "QD", "5D", "7D", "6C", "QH", "KC", "3H", "8S", "9C"},
    {"F3", "10C", "AC", "2D", "4S", "6H", "8H", "JS", "AD", "F4"}
    };
    Player Player1 = Player("P1", BLUE, 6);
    Player Player2 = Player("P2", RED, 6);
    Player Player3 = Player("P3", GREEN, 6);

    std::vector<Player> players = { Player1, Player2, Player3 };


    std::vector<std::pair<Team, std::pair<int, int>>> tileMap;
    play(gameBoard, players, tileMap);

    You might also like