304 lines
No EOL
9 KiB
C++
304 lines
No EOL
9 KiB
C++
/*
|
|
Program Name: Cards
|
|
Process: This is primarily a definition of a card class, for some terminal card games.
|
|
Function Input/Parameters: ???
|
|
Function Output/Parameters: ???
|
|
Function Output/Returned: ???
|
|
Device Input/Device: ???
|
|
Device Output/Monitor: ???
|
|
Dependencies: ???
|
|
*/
|
|
|
|
#include "cards.h"
|
|
|
|
using namespace std;
|
|
// using namespace Cards;
|
|
|
|
// 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 getCardRawValue()
|
|
{
|
|
return cardValue;
|
|
}
|
|
char getCardSuit()
|
|
{
|
|
return cardSuit;
|
|
}
|
|
string getFullCard()
|
|
{
|
|
return fullCard;
|
|
}
|
|
void switchComparison(CardSwitch switchComp = VALUE)
|
|
{
|
|
//
|
|
if(switchComp == VALUE)
|
|
{
|
|
//
|
|
Card::compareValue = true;
|
|
Card::compareSuit = false;
|
|
Card::compareCard = false;
|
|
}
|
|
else if(switchComp == SUIT)
|
|
{
|
|
Card::compareValue = false;
|
|
Card::compareSuit = true;
|
|
Card::compareCard = false;
|
|
}
|
|
else
|
|
{
|
|
Card::compareValue = false;
|
|
Card::compareSuit = false;
|
|
Card::compareCard = true;
|
|
}
|
|
}
|
|
void switchInput(CardSwitch switchComp = FULLCARD)
|
|
{
|
|
//
|
|
if (switchComp == VALUE)
|
|
{
|
|
//
|
|
Card::inputValue = true;
|
|
Card::inputSuit = false;
|
|
Card::inputCard = false;
|
|
}
|
|
else if (switchComp == SUIT)
|
|
{
|
|
Card::inputValue = false;
|
|
Card::inputSuit = true;
|
|
Card::inputCard = false;
|
|
}
|
|
else
|
|
{
|
|
Card::inputValue = false;
|
|
Card::inputSuit = false;
|
|
Card::inputCard = true;
|
|
}
|
|
}
|
|
void switchOutput(CardSwitch switchComp = FULLCARD)
|
|
{
|
|
//
|
|
if (switchComp == VALUE)
|
|
{
|
|
//
|
|
Card::outputValue = true;
|
|
Card::outputSuit = false;
|
|
Card::outputCard = false;
|
|
}
|
|
else if (switchComp == SUIT)
|
|
{
|
|
Card::outputValue = false;
|
|
Card::outputSuit = true;
|
|
Card::outputCard = false;
|
|
}
|
|
else
|
|
{
|
|
Card::outputValue = false;
|
|
Card::outputSuit = false;
|
|
Card::outputCard = true;
|
|
}
|
|
}
|
|
friend bool operator==(const Card &cardOne, const Card &cardTwo)
|
|
{
|
|
// operator== can decide whether or not it will compare the
|
|
// values of cards, suits of cards, or complete cards, defaults to
|
|
// comparing values of cards only.
|
|
// to switch the comparison operator, use the switchComparison function
|
|
// to switch how the comparison operator works.
|
|
if(compareSuit)
|
|
{
|
|
return (cardOne.cardSuit == cardTwo.cardSuit);
|
|
}
|
|
else if(compareCard)
|
|
{
|
|
return ((cardOne.cardNumericalValue == cardTwo.cardNumericalValue)
|
|
&& (cardOne.cardSuit == cardTwo.cardSuit));
|
|
}
|
|
else
|
|
{
|
|
return (cardOne.cardNumericalValue == cardTwo.cardNumericalValue);
|
|
}
|
|
}
|
|
friend bool operator<(const Card &cardOne, const Card &cardTwo)
|
|
{
|
|
// compare cardOne's value to cardTwo's value with less than function.
|
|
// THIS WILL ONLY CHECK NUMERICAL VALUE
|
|
return (cardOne.cardNumericalValue < cardTwo.cardNumericalValue);
|
|
}
|
|
friend ostream &operator<<(ostream &output, const Card &cardOut)
|
|
{
|
|
// operator<< can decide whether or not it will output the
|
|
// values of cards, suits of cards, or complete cards, defaults to
|
|
// printing full card value.
|
|
// to switch the output operator, use the switchOutput function
|
|
// to switch how the output operator works.
|
|
if (outputValue)
|
|
{
|
|
return output << cardOut.cardValue;
|
|
}
|
|
else if (outputSuit)
|
|
{
|
|
return output << cardOut.cardSuit;
|
|
}
|
|
else
|
|
{
|
|
return output << cardOut.fullCard;
|
|
}
|
|
}
|
|
friend istream &operator>>(istream &input, Card &cardIn)
|
|
{
|
|
// operator>> can decide whether or not it will input the
|
|
// values of cards, suits of cards, or complete cards, defaults to
|
|
// getting input of full card value in format NumberSuit (aka 2D for 2 of Diamonds).
|
|
// to switch the input operator, use the switchInput function
|
|
// to switch how the input operator works.
|
|
|
|
// get a temporary string in.
|
|
string inStr;
|
|
// read in the input into the temp string.
|
|
input >> inStr;
|
|
// grab the input based on what is currently set for the class.
|
|
if (outputValue)
|
|
{
|
|
// assume the input is a single value, cast from string to char
|
|
cardIn.cardNumericalValue = atoi(inStr.c_str());
|
|
cardIn.cardValue = (char)cardIn.cardNumericalValue + 48; // needs testing.
|
|
return input;
|
|
}
|
|
else if (outputSuit)
|
|
{
|
|
// assume the input is a single value, cast from string to char
|
|
cardIn.cardSuit = inStr.c_str()[0]; // this may not work.
|
|
return input;
|
|
}
|
|
else
|
|
{
|
|
cardIn.cardNumericalValue = atoi(inStr.c_str());
|
|
cardIn.cardValue = (char)cardIn.cardNumericalValue + 48;
|
|
cardIn.fullCard = inStr;
|
|
return input;
|
|
}
|
|
}
|
|
|
|
private:
|
|
char cardValue;
|
|
char cardSuit;
|
|
int cardNumericalValue;
|
|
string fullCard;
|
|
// comparison defaults to value
|
|
static bool compareValue; // unused?
|
|
static bool compareSuit;
|
|
static bool compareCard;
|
|
// output defaults to full card value
|
|
static bool outputValue;
|
|
static bool outputSuit;
|
|
static bool outputCard;
|
|
// input defaults to full card value
|
|
static bool inputValue;
|
|
static bool inputSuit;
|
|
static bool inputCard;
|
|
};
|
|
|
|
// function prototypes
|
|
|
|
bool compareValue = true;
|
|
bool compareSuit = false;
|
|
bool compareCard = false;
|
|
bool outputValue = false;
|
|
bool outputSuit = false;
|
|
bool outputCard = true;
|
|
bool inputValue = false;
|
|
bool inputSuit = false;
|
|
bool inputCard = true;
|
|
|
|
// 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;
|
|
// 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);
|
|
// 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 cards.cpp -o cards" - note to programmer
|