2011-02-09 98 views
0

我正在寫一個在終端中運行的紙牌遊戲。截至目前,該程序編譯並運行,給玩家四張牌,分爲四列,並允許他們按0來獲取更多牌,並將其添加到列中。隨着列的增長,它的輸出應該放置在一個向量中(實際上是向量的向量)。小C++遊戲幫助

理想情況下,如果需要收集更多卡片,玩家將輸入一個範圍爲1-4的數字,以選擇他們想要與其他人比較的列。然後它應該將該列的頂部牌與其他頂牌進行比較,看看是否可以刪除。這是我遇到麻煩的部分。首先,我不確定是否將卡片正確輸入矢量矢量中,而我不知道如何將它們相互比較。我嘗試使用類似的東西:

column[2].back().getSuit()訪問第二列的頂部卡的訴訟,然後給它一個數值,並將其與其他的訴訟進行比較。 我做了類似的事情來比較卡的排名,但我沒有任何運氣。

任何人都可以使用我或你自己的代碼給我看一個例子嗎? 我應該如何正確比較每列中頂級牌的花色和等級?

這是到目前爲止我的代碼:

#include <iostream> 
#include <algorithm> 
#include <vector> 
#include <cstdlib> 
#include <ctime> 

using namespace std; 

enum suits 
{ 
    diamond, club, heart, spade 
}; 

class Card 
{ 
private: 
    int rank; 
    suits suit; 
public: 
    Card(); 
    Card(suits, int); 
    int getRank() { return rank; } 
    suits getSuit() { return suit; } 
    void setRank(int rankvalue) { rank = rankvalue; } 
    void setSuit(suits suitvalue) { suit = suitvalue; } 
}; 

ostream & operator<<(ostream &, Card); 

Card::Card() 
{ 
    rank = 1; 
    suit = spade; 
} 

Card::Card(suits suitvalue, int rankvalue) 
{ 
    rank = rankvalue; 
    suit = suitvalue; 
} 

ostream & operator<<(ostream & out, Card aCard) 
{ 
    switch (int rank = aCard.getRank()) 
    { 
     case 14: out << "Ace"; break; 
     case 11: out << "Jack"; break; 
     case 12: out << "Queen"; break; 
     case 13: out << "King"; break; 
     default: out << rank; 
    } 

    switch (suits suit = aCard.getSuit()) 
    { 
     case diamond: out << " of Diamonds"; break; 
     case spade: out << " of Spades"; break; 
     case heart: out << " of Hearts"; break; 
     case club: out << " of Clubs"; break; 
    } 

    return out; 
} 

class RandomInteger 
{ 
public: 
    RandomInteger(); 
    unsigned int operator() (unsigned int max); 
}; 

RandomInteger::RandomInteger() 
{ 
    srand(time(0)); 
} 

unsigned int RandomInteger::operator()(unsigned int max) 

{ 
    unsigned int rval = rand(); 
    return rval % max; 
} 

RandomInteger randomizer; 

class Deck 
{ 
    Card cards[52]; 
    int topCard; 
public: 
    Deck(); 
    void shuffle(); 
    bool isEmpty() { return topCard <= 0; } 
    Card draw(); 
}; 

extern RandomInteger randomizer; 

Deck::Deck() 
{ 
    topCard = 0; 
    for (int i = 1; i <= 13; i++) 
    { 
     Card c1(diamond, i), c2(spade, i), c3(heart, i), c4(club, i); 
     cards[topCard++] = c1; 
     cards[topCard++] = c2; 
     cards[topCard++] = c3; 
     cards[topCard++] = c4; 
    } 
} 

Card Deck::draw() 
{ 
    if (!isEmpty()) 
     return cards[--topCard]; 
    else 
    { 
     Card spadeAce(spade, 1); 
     return spadeAce; 
    } 
} 

void Deck::shuffle() 
{ 
    random_shuffle(cards, cards+52, randomizer); 
} 

class Player 
{ 
public: 
    Player(); 
    void print(); 
    Card draw(Deck &); 
    typedef vector<Card> cards; 
    vector<cards> column; 
}; 

//ostream & operator<<(ostream &, Player&); 

Player::Player() 
{ 
    column.push_back(vector<Card>()); 
    column.push_back(vector<Card>()); 
    column.push_back(vector<Card>()); 
    column.push_back(vector<Card>()); 
} 

Card Player::draw(Deck & aDeck) 
{ 
    for (int i = 0; i < 4; i++) 
     column[i].push_back(aDeck.draw()); 
} 

void Player::print() 
{ 
    cout << "Col 1 \t\t Col 2 \t\t Col 3 \t\t Col 4 \n"; 
    bool more = true; 
    for (int j = 0; more; j++) 
    { 
     more = false; 
     for (int i = 0; i < 4; i++) 
      if (j < column[i].size()) 
     { 
     cout << column[i][j] << "\t"; 
     more = true; 
     } 
      else 
      cout << "\t\t"; 
    cout << endl; 
    } 
} 

int main() 
{ 
    Deck deck; 
    deck.shuffle(); 

    Player player; 
    player.draw(deck); 
    //while (!deck.isEmpty()) 
    //{ 
    cout << "Enter a column number (0 to draw four new cards): " << endl; 
    //} 
    player.print(); 

    int input; 
    int i; 
    vector<vector<Card> > columns(4); 
    while (cin >> input) 
    if (input == 0) 
    { 
     player.draw(deck); 
     player.print(); 
     columns.push_back(vector<Card>()); 
     columns.push_back(vector<Card>()); 
    columns.push_back(vector<Card>()); 
     columns.push_back(vector<Card>()); 
    } 
     else while (cin >> input) 
      if (input == 1) 
      { 
      for (i = 0; i > 4; i++) 
       { 
         columns.push_back(vector<Card>()); 
      } 
      for (i = 0; i > 4; i++) 
        { 
        columns[0].back().getSuit(); 
       columns[1].back().getSuit(); 
       columns[2].back().getSuit(); 
       columns[3].back().getSuit(); 
      } 

      } 



} 

任何建議,三分球,技巧,是偉大的,謝謝。

+1

我不想鼓勵你crosspost,但你應該看看http://gamedev.stackexchange.com/。 – chaos 2011-02-09 17:00:29

+1

您需要了解您的類如何相互交互,並在開始編碼之前考慮這個問題。您之前的問題表明,您已經花時間查看提供給您的代碼並試圖理解它。你現在走在正確的軌道上,但你需要問問自己,我怎樣才能讓卡/玩家/甲板/隨機類共同工作來解決我的問題。 – Grammin 2011-02-09 17:05:27

回答

2

您不需要將套裝翻譯成數值進行比較。您可以直接比較枚舉類型。

嘗試添加比較運算符Card S:

bool operator==(const Card& a, const Card& b) { 
    return a.getRank() == b.getRank() && a.getSuit() == b.getSuit(); 
} 

對於這個工作,你必須標記getRankgetSuit方法與const

int getRank() const { return rank; } 
suits getSuit() const { return suit; } 

現在你應該能夠簡單地比較任意兩張卡片,包括兩列「頂部」的卡片。例如:

if (columns[1].back() == columns[2].back()) { ... } 

請注意,如果向量爲空,back將不起作用。

+0

感謝,它編譯但不工作,所以我假設我做了一件錯誤的載體,就像你提到的。 – UndefinedReference 2011-02-09 17:45:22

1

Hia的,你自找的建議,所以我想我建議兩件事

所有我喜歡讓枚舉類型的第一和一起返回一個字符串,以防萬一我添加到枚舉類型的功能後來(在這種情況下admitadly不太可能)

class suits{ 
public: 
    enum type{ 
    diamond, club, heart, spade, 
    }; 

    static 
    std::string get_string(const type& t) 
    { 
    switch (t) { 
    case diamond: return"Diamonds"; 
    case spade: return"Spades"; 
    case heart: return"Hearts"; 
    case club: return"Clubs"; 
    } 
    throw("invalid suit"); //this is a bit ugly - but you get the idea 
    } 
}; 

然後,您可以參考suits::spadesuits::get_string(suits::spade)等,這可有點清晰。

那麼我將有西裝,在自己的班級數,那麼你可以在這裏做了比較:

class CardSuit 
{ 
private: 
    suits::type m_suit; 
protected: 
    std::string get_string() const {return suits::get_string(m_suit);} 
public: 
    CardSuit(const suits::type& t) : m_suit(t) {} 
    void setSuit(const suits::type& t) { m_suit = t;} 
    const suits::type& getSuit() const {return m_suit;} 
    bool operator<(CardSuit cs) 
    { 
    return m_suit<cs.getSuit(); //You must have the enum in the suit order 
    } 
}; 

然後

CardSuit club(suits::club); 
    CardSuit spade(suits::spade); 

    if (club<spade) 
    std::cout<<"true"<<std::endl; 
    else 
    std::cout<<"false"<<std::endl; 

返回true

然後,您可以從CardSuit類繼承,像這樣

class Card : public CardSuit 
{ 
private: 
    int rank; 
public: 
    Card(); 
    Card(suits::type, int); 
    int getRank() { return rank; } 
    void setRank(int rankvalue) { rank = rankvalue; } 
    std::string get_suit() const {return CardSuit::get_string();} 

bool operator<(const Card& c) 
    { 
    if (CardSuit::operator<(c)) 
     return true; 
    if (rank<c.getRank()) 
     return true; 
    else return false; 
    } 
}; 

使

Card c1(suits::club, 4); 
    Card c2(suits::club, 5); 
    Card c3(suits::diamond, 5); 

    if (c2<c1) 
    std::cout<<"true"<<std::endl; 
    else 
    std::cout<<"false"<<std::endl; 

    if (c3<c1) 
    std::cout<<"true"<<std::endl; 
    else 
    std::cout<<"false"<<std::endl; 

回報虛實分別

最後 utstream操作是一樣的東西

ostream & operator<<(ostream & out, Card aCard) 
{ 
    switch (int rank = aCard.getRank()) 
    { 
    case 14: out << "Ace"; break; 
    case 11: out << "Jack"; break; 
    case 12: out << "Queen"; break; 
    case 13: out << "King"; break; 
    default: out << rank; 
    } 

    out << " of "<< aCard.get_suit(); 

    return out; 
} 

(我也做出類似的CardSuit類排名等級 - 中它甚至更加整潔)。