-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathCards.cpp
More file actions
207 lines (151 loc) · 6.86 KB
/
Copy pathCards.cpp
File metadata and controls
207 lines (151 loc) · 6.86 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
#include "Cards.h"
#include "Player.h"
#include <cstring>
// Used to convert enum to string
const char* CardTypeString[] = { "Bomb", "Reinforcement", "Blockade", "Airlift", "Diplomacy" };
/****************************************************************/
/************************** DECK CLASS **************************/
/****************************************************************/
/******************* DECK CONSTRUCTOR *******************/
Deck::Deck() : deckCards() {
};
/******************** DECK DESTRUCTOR *******************/
Deck::~Deck() {
for (Card* card : deckCards)
delete card;
};
/***************** DECK COPY CONSTRUCTOR *****************/
Deck::Deck(const Deck &deck) {
for (Card* card : deck.deckCards)
deckCards.push_back(new Card(*card));
};
/**************** DECK ASSIGNMENT OPERATOR ***************/
Deck& Deck::operator =(const Deck &deck) {
deckCards = deck.deckCards;
return *this;
};
/***************** DECK STREAM OPERATOR *****************/
ostream& operator<<(std::ostream& out, const Deck& deck) {
out << setw(15) << "------------------- DECK CARDS ------------------ \n";
out << left << setw(15) << "Card Type" << left << setw(20)<< "Card Reference" << left << setw(20) << "Type Reference" << endl;
for (int i = 0; i < deck.deckCards.size(); i++)
out << deck.deckCards[i];
return out;
}
Card* Deck::draw() {
auto randomSeed = std::mt19937(std::random_device{}()); // Generates random seed (ensures each run will generate new unique shuffle)
auto random = default_random_engine { randomSeed() }; // Generates random number
shuffle(deckCards.begin(), deckCards.end(), random); // Shuffles vector according to random
Card* pCard = deckCards.back(); // Store card pointer
deckCards.pop_back(); // Remove pointer
return pCard; // Return card pointer
};
/******************* DECK FILL FUNCTION *******************/
void Deck::fillDeck(int deckSize) {
int adjustedSize = ((deckSize + 5/2) / 5); // Nearest multiple of 5 (divided by 5 to account for each type)
// Add each type of card according to the adjusted amount
for (int i = 0; i < adjustedSize; i++) {
// Push new Card with new CardType to the deck
deckCards.push_back(new Card(new CardType(CardType::Bomb)));
deckCards.push_back(new Card(new CardType(CardType::Reinforcement)));
deckCards.push_back(new Card(new CardType(CardType::Blockade)));
deckCards.push_back(new Card(new CardType(CardType::Airlift)));
deckCards.push_back(new Card(new CardType(CardType::Diplomacy)));
}
};
/******************** DECK PRINT OUTPUT *******************/ // NOT IN USE CURRENTLY
void Deck::printDeckOutput() {
cout << left << setw(5) << "#" << left << setw(15) << "Card Type" << left << setw(20)<< "Type Reference" << left << setw(20) << "Card Reference" << endl;
for (int i = 0; i < deckCards.size(); i++)
{
CardType cType = *(deckCards[i]->cardType);
cout << left << setw(5) << (i + 1)
<< left << setw(15) << CardTypeString[static_cast<int>(cType)]
<< left << setw(20) << deckCards[i]->cardType
<< left << setw(20) << &deckCards[i]
<< endl;
}
};
/****************************************************************/
/************************** CARD CLASS **************************/
/****************************************************************/
/******************* CARD CONSTRUCTOR *******************/
Card::Card() {
};
/******************** CARD DESTRUCTOR *******************/
Card::~Card() {
delete cardType;
};
/***************** CARD COPY CONSTRUCTOR *****************/
Card::Card(const Card &card) {
cardType = card.cardType;
};
/**************** CARD ASSIGNMENT OPERATOR ***************/
Card& Card::operator =(const Card &card) {
cardType = card.cardType;
return *this;
};
/***************** CARD STREAM OPERATOR *****************/
ostream& operator<<(std::ostream& out, const Card* card) {
out << left << setw(15) << CardTypeString[static_cast<int>(*(card->cardType))]
<< left << setw(20) << static_cast<void const *>(card)
<< left << setw(20) << card->cardType
<< endl;
return out;
}
/***************** CARD STREAM OPERATOR *****************/
CardType* Card::getCardType() {
return cardType;
};
// /******************* CARD PLAY FUNCTION *******************/
// void Card::play(Player* player, Deck* mainDeck) {
// // Adds order to player orders according to string value of cardtype
// if (strcmp(CardTypeString[static_cast<int>(*(this->cardType))], "Diplomacy") == 0) {
// player->issueOrder("Negotiate");
// }
// else if (strcmp(CardTypeString[static_cast<int>(*(this->cardType))], "Reinforcement") == 0)
// player->issueOrder("Advance");
// else
// player->issueOrder(CardTypeString[static_cast<int>(*(this->cardType))]);
// auto element = find(player->myHand->handCards.begin(), player->myHand->handCards.end(), this); // Finds element
// int elementIndex = distance(player->myHand->handCards.begin(), element); // Gets element index
// mainDeck->deckCards.push_back(move(this)); // Moves card pointer back to deck
// player->myHand->handCards.erase(element); // Erases card pointer from hand
// };
/****************************************************************/
/************************** HAND CLASS **************************/
/****************************************************************/
/******************* HAND CONSTRUCTOR *******************/
Hand::Hand() : handCards() {
};
/******************** HAND DESTRUCTOR *******************/
Hand::~Hand() {
for (Card* card : handCards) {
delete card;
}
};
/***************** HAND COPY CONSTRUCTOR *****************/
Hand::Hand(const Hand &hand) {
for (Card* card : hand.handCards)
handCards.push_back(new Card(*card));
};
/**************** HAND ASSIGNMENT OPERATOR ***************/
Hand& Hand::operator =(const Hand &hand) {
handCards = hand.handCards;
return *this;
};
/***************** HAND STREAM OPERATOR *****************/
ostream& operator<<(std::ostream& out, const Hand* hand) {
out << setw(15) << "------------------ Player Hand ------------------ \n";
out << left << setw(18) << "Card Type" << left << setw(20)<< "Card Reference" << left << setw(20) << "Type Reference" << endl;
for (int i = 0; i < hand->handCards.size(); i++)
out << (i + 1) << ": " << hand->handCards[i];
return out;
};
bool Hand::containsCardType(string type) {
for (int i = 0; i < this->handCards.size(); i++) {
if (type == CardTypeString[static_cast<int>(*(this->handCards[i]->cardType))])
return true;
}
return false;
}