222 lines
No EOL
7.7 KiB
C++
222 lines
No EOL
7.7 KiB
C++
/*
|
||
Program Name: Go Fish
|
||
Process: Does the following according to spec:
|
||
Players take turns asking their opponent for a specific card. The game will continue until all sets are
|
||
collected.
|
||
Here are the rules of the game:
|
||
● Use a 52-card deck
|
||
● Deal 7 cards to each player (human and computer).
|
||
Each play will take turns asking for a card rank/number from the opponent. If the opponent has the card
|
||
that is requested, they must hand over all the cards of that rank/number. If the opponent does not have the
|
||
card requested, then the player number “go fish” meaning they must draw a card from the deck. If a
|
||
player collects a set of four cards of the same rank, they will lay down the set and earn a point. The game
|
||
will end when all sets have been collected.
|
||
Function requirements:
|
||
● humanTurn
|
||
○ Handles the human’s turn. It will prompt the player to ask for a card rank/number and
|
||
check if the computer has the requested rank/number. If the card is available in the
|
||
computer’s hand, it will transfer the card to the human’s hand otherwise, it will draw a
|
||
card. The function should return the number of sets collected during the turn
|
||
● computerTurn
|
||
○ Handles the computer’s turn and it should do the same actions as the human but for the
|
||
computer. The function should return the number of set that is collected during its turn.
|
||
Function Input/Parameters: ???
|
||
Function Output/Parameters: ???
|
||
Function Output/Returned: ???
|
||
Device Input/Device: ???
|
||
Device Output/Monitor: ???
|
||
Dependencies: ???
|
||
*/
|
||
|
||
#include <cstdio>
|
||
#include <cstdlib>
|
||
#include <iostream>
|
||
#include <cstring>
|
||
#include <vector>
|
||
#include <random>
|
||
#include <algorithm>
|
||
#include <time.h>
|
||
|
||
using namespace std;
|
||
|
||
// class definitions
|
||
class Card
|
||
{
|
||
//
|
||
public:
|
||
Card(char value, char suit)
|
||
{
|
||
// store the value and suit. (possible values 2-9, T, J, Q, K, A)
|
||
cardValue = value;
|
||
cardSuit = suit;
|
||
// get the numerical value of the card, casting from string to num where possible. (2-9)
|
||
if((cardValue >= 2) || (cardValue <= 9))
|
||
{
|
||
// cast the character to number.
|
||
cardNumericalValue = (int)cardValue - 48; // numerical values 2-9 only
|
||
}
|
||
// face values here.
|
||
if(cardValue == 'T')
|
||
{
|
||
// 'ten' card
|
||
cardNumericalValue = 10;
|
||
}
|
||
if(cardValue == 'J')
|
||
{
|
||
// jack
|
||
cardNumericalValue = 11;
|
||
}
|
||
if(cardValue == 'Q')
|
||
{
|
||
// queen
|
||
cardNumericalValue = 12;
|
||
}
|
||
if(cardValue == 'K')
|
||
{
|
||
// king
|
||
cardNumericalValue = 13;
|
||
}
|
||
// special 1/Ace card here
|
||
if (cardValue == 'A')
|
||
{
|
||
cardNumericalValue = 1;
|
||
}
|
||
// add the cardValue and cardSuit to the string
|
||
fullCard = fullCard + cardValue;
|
||
fullCard = fullCard + cardSuit;
|
||
}
|
||
int getCardValue()
|
||
{
|
||
//
|
||
return cardNumericalValue;
|
||
}
|
||
char getCardSuit()
|
||
{
|
||
//
|
||
return cardSuit;
|
||
}
|
||
string getFullCard()
|
||
{
|
||
return fullCard;
|
||
}
|
||
private:
|
||
char cardValue;
|
||
char cardSuit;
|
||
int cardNumericalValue;
|
||
string fullCard;
|
||
};
|
||
|
||
// function prototypes
|
||
int humanTurn(vector<Card> &human, vector<Card> &computer);
|
||
int computerTurn(vector<Card> &human, vector<Card> &computer);
|
||
|
||
// main program
|
||
int main(int argc, char **argv)
|
||
{
|
||
// create array of cards called deck.
|
||
vector<Card> deck;
|
||
// have two hands for cards
|
||
vector<Card> humanHand;
|
||
vector<Card> computerHand;
|
||
// keep count of the number of sets collected. ends when number is 13.
|
||
int currentNumSets = 0;
|
||
// char array for the setups
|
||
char suits[] = {'C','D','H','S'};
|
||
int suitsLen = sizeof(suits)/sizeof(suits[0]);
|
||
// char values[] = {'A','2','3','4','5','6','7','8','9','T','J','Q','K'};
|
||
char values[] = {'K','Q','J','T','9','8','7','6','5','4','3','2','A'};
|
||
int valuesLen = (sizeof(values)/sizeof(values[0]));
|
||
// game setup
|
||
// create deck by loop for 1 - 13 with each suit {(H)earts, S(pades), C(lubs), D(iamonds)}.
|
||
// use double for loop, outer for suits, inner for values.
|
||
for (int deckCounter = 0; deckCounter < suitsLen; deckCounter++)
|
||
{
|
||
// creates each suit
|
||
for (int suitCounter = 0; suitCounter < valuesLen; suitCounter++)
|
||
{
|
||
// creates each card/value
|
||
deck.push_back(Card(values[suitCounter], suits[deckCounter]));
|
||
}
|
||
}
|
||
// shuffle deck randomly? (use shuffle function from algorithm library)
|
||
// generate a random number (which is so much harder in CPP because they 'frown upon' using the C STL rand stuff)
|
||
default_random_engine randNumGen(time(NULL));
|
||
// shuffle the deck using that rng engine.
|
||
shuffle(deck.begin(), deck.end(), randNumGen);
|
||
// deal hands by taking each card from the deck, one by one (7x) (for loop here.)
|
||
for(int dealIterator = 0; dealIterator < 7; dealIterator++)
|
||
{
|
||
// grab the last card from the deck, put it in the human's hand
|
||
humanHand.push_back(deck.back());
|
||
deck.pop_back();
|
||
// grab the last card from the deck, put it in the computer's hand
|
||
computerHand.push_back(deck.back());
|
||
deck.pop_back();
|
||
}
|
||
// main gameplay loop (while?)
|
||
while(currentNumSets != 13)
|
||
{
|
||
// switch back and forth between human and computer.
|
||
currentNumSets = currentNumSets + humanTurn(humanHand, computerHand);
|
||
currentNumSets = currentNumSets + computerTurn(humanHand, computerHand);
|
||
}
|
||
// return 0
|
||
return 0;
|
||
}
|
||
|
||
/* THIS BELOW CODE IS FOR CHECKING THE DECK
|
||
for (int tempIterator = 0; tempIterator < 52; tempIterator++)
|
||
{
|
||
// print off each card to see if it was correctly made.
|
||
cout << tempIterator << ": " << deck[tempIterator].getFullCard() << " | ";
|
||
}
|
||
cout << endl;
|
||
*/
|
||
|
||
// compiles using "g++ -Wall -pedantic go_fish.cpp -o go_fish" - note to programmer
|
||
|
||
/*
|
||
Function Name: humanTurn
|
||
Process: ???
|
||
Function Input/Parameters: ???
|
||
Function Output/Parameters: ???
|
||
Function Output/Returned: ???
|
||
Device Input/Device: ???
|
||
Device Output/Monitor: ???
|
||
Dependencies: ???
|
||
*/
|
||
int humanTurn(vector<Card> &human, vector<Card> &computer)
|
||
{
|
||
/*
|
||
Handles the human’s turn. It will prompt the player to ask for a card rank/number and
|
||
check if the computer has the requested rank/number. If the card is available in the
|
||
computer’s hand, it will transfer the card to the human’s hand otherwise, it will draw a
|
||
card. The function should return the number of sets collected during the turn
|
||
*/
|
||
|
||
// ask for card rank/number/value
|
||
// if card is in hand,
|
||
|
||
// return the number of sets
|
||
return 0;
|
||
}
|
||
|
||
/*
|
||
Function Name: computerTurn
|
||
Process: ???
|
||
Function Input/Parameters: ???
|
||
Function Output/Parameters: ???
|
||
Function Output/Returned: ???
|
||
Device Input/Device: ???
|
||
Device Output/Monitor: ???
|
||
Dependencies: ???
|
||
*/
|
||
int computerTurn(vector<Card> &human, vector<Card> &computer)
|
||
{
|
||
/*
|
||
Handles the computer’s turn and it should do the same actions as the human but for the
|
||
computer. The function should return the number of set that is collected during its turn.
|
||
*/
|
||
// return the number of sets
|
||
return 0;
|
||
} |